import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import io.netty.util.concurrent.EventExecutor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
+import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapabilityBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.unavailable.capabilities.UnavailableCapability;
-import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
+import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.rfc8528.model.api.SchemaMountConstants;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcError;
/**
* This is a mediator between NetconfDeviceCommunicator and NetconfDeviceSalFacade.
*/
-public class NetconfDevice
- implements RemoteDevice<NetconfSessionPreferences, NetconfMessage, NetconfDeviceCommunicator> {
-
- @SuppressFBWarnings(value = "SLF4J_LOGGER_SHOULD_BE_PRIVATE",
- justification = "Needed for common logging of related classes")
- static final Logger LOG = LoggerFactory.getLogger(NetconfDevice.class);
+public class NetconfDevice implements RemoteDevice<NetconfDeviceCommunicator> {
+ private static final Logger LOG = LoggerFactory.getLogger(NetconfDevice.class);
private static final QName RFC8528_SCHEMA_MOUNTS_QNAME = QName.create(
SchemaMountConstants.RFC8528_MODULE, "schema-mounts").intern();
protected final List<SchemaSourceRegistration<?>> sourceRegistrations = new ArrayList<>();
- private final RemoteDeviceHandler<NetconfSessionPreferences> salFacade;
+ private final RemoteDeviceHandler salFacade;
private final ListeningExecutorService processingExecutor;
private final DeviceActionFactory deviceActionFactory;
private final NetconfDeviceSchemasResolver stateSchemasResolver;
private boolean connected = false;
// Message transformer is constructed once the schemas are available
- private MessageTransformer<NetconfMessage> messageTransformer;
+ private MessageTransformer messageTransformer;
public NetconfDevice(final SchemaResourcesDTO schemaResourcesDTO, final BaseNetconfSchemas baseSchemas,
- final RemoteDeviceId id, final RemoteDeviceHandler<NetconfSessionPreferences> salFacade,
+ final RemoteDeviceId id, final RemoteDeviceHandler salFacade,
final ListeningExecutorService globalProcessingExecutor, final boolean reconnectOnSchemasChange) {
this(schemaResourcesDTO, baseSchemas, id, salFacade, globalProcessingExecutor, reconnectOnSchemasChange, null,
null, null, null);
}
public NetconfDevice(final SchemaResourcesDTO schemaResourcesDTO, final BaseNetconfSchemas baseSchemas,
- final RemoteDeviceId id, final RemoteDeviceHandler<NetconfSessionPreferences> salFacade,
+ final RemoteDeviceId id, final RemoteDeviceHandler salFacade,
final ListeningExecutorService globalProcessingExecutor, final boolean reconnectOnSchemasChange,
final DeviceActionFactory deviceActionFactory, final NetconfNode node, final EventExecutor eventExecutor,
final NetconfNodeAugmentedOptional nodeOptional) {
this.node = node;
this.eventExecutor = eventExecutor;
this.nodeOptional = nodeOptional;
- this.schemaRegistry = schemaResourcesDTO.getSchemaRegistry();
- this.schemaRepository = schemaResourcesDTO.getSchemaRepository();
- this.schemaContextFactory = schemaResourcesDTO.getSchemaContextFactory();
+ schemaRegistry = schemaResourcesDTO.getSchemaRegistry();
+ schemaRepository = schemaResourcesDTO.getSchemaRepository();
+ schemaContextFactory = schemaResourcesDTO.getSchemaContextFactory();
this.salFacade = salFacade;
- this.stateSchemasResolver = schemaResourcesDTO.getStateSchemasResolver();
- this.processingExecutor = requireNonNull(globalProcessingExecutor);
- this.notificationHandler = new NotificationHandler(salFacade, id);
+ stateSchemasResolver = schemaResourcesDTO.getStateSchemasResolver();
+ processingExecutor = requireNonNull(globalProcessingExecutor);
+ notificationHandler = new NotificationHandler(salFacade, id);
}
@Override
@Override
public void onSuccess(final MountPointContext result) {
handleSalInitializationSuccess(result, remoteSessionCapabilities,
- getDeviceSpecificRpc(result, listener), listener);
+ getDeviceSpecificRpc(result, listener, baseSchema), listener);
}
@Override
@Override
public void onSuccess(final DOMRpcResult domRpcResult) {
notificationHandler.addNotificationFilter(notification -> {
- if (NetconfCapabilityChange.QNAME.equals(notification.getBody().getNodeType())) {
+ if (NetconfCapabilityChange.QNAME.equals(notification.getBody().getIdentifier().getNodeType())) {
LOG.info("{}: Schemas change detected, reconnecting", id);
// Only disconnect is enough,
// the reconnecting nature of the connector will take care of reconnecting
return remoteSessionCapabilities.isNotificationsSupported() && reconnectOnSchemasChange;
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private synchronized void handleSalInitializationSuccess(final MountPointContext result,
- final NetconfSessionPreferences remoteSessionCapabilities,
- final DOMRpcService deviceRpc,
- final RemoteDeviceCommunicator<NetconfMessage> listener) {
+ final NetconfSessionPreferences remoteSessionCapabilities, final DOMRpcService deviceRpc,
+ final RemoteDeviceCommunicator listener) {
//NetconfDevice.SchemaSetup can complete after NetconfDeviceCommunicator was closed. In that case do nothing,
//since salFacade.onDeviceDisconnected was already called.
if (connected) {
- this.messageTransformer = new NetconfMessageTransformer(result, true,
+ messageTransformer = new NetconfMessageTransformer(result, true,
resolveBaseSchema(remoteSessionCapabilities.isNotificationsSupported()));
// salFacade.onDeviceConnected has to be called before the notification handler is initialized
- this.salFacade.onDeviceConnected(result, remoteSessionCapabilities, deviceRpc,
- this.deviceActionFactory == null ? null : this.deviceActionFactory.createDeviceAction(
- this.messageTransformer, listener, result.getEffectiveModelContext()));
- this.notificationHandler.onRemoteSchemaUp(this.messageTransformer);
+ salFacade.onDeviceConnected(result, remoteSessionCapabilities, deviceRpc,
+ deviceActionFactory == null ? null : deviceActionFactory.createDeviceAction(
+ messageTransformer, listener, result.getEffectiveModelContext()));
+ notificationHandler.onRemoteSchemaUp(messageTransformer);
LOG.info("{}: Netconf connector initialized successfully", id);
} else {
}
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
- private void handleSalInitializationFailure(final Throwable throwable,
- final RemoteDeviceCommunicator<NetconfMessage> listener) {
+ private void handleSalInitializationFailure(final Throwable throwable, final RemoteDeviceCommunicator listener) {
LOG.error("{}: Initialization in sal failed, disconnecting from device", id, throwable);
listener.close();
onRemoteSessionDown();
updateTransformer(null);
}
- private synchronized void updateTransformer(final MessageTransformer<NetconfMessage> transformer) {
+ private synchronized void updateTransformer(final MessageTransformer transformer) {
messageTransformer = transformer;
}
this.connected = connected;
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private ListenableFuture<EffectiveModelContext> assembleSchemaContext(final DeviceSources deviceSources,
final NetconfSessionPreferences remoteSessionCapabilities) {
LOG.debug("{}: Resolved device sources to {}", id, deviceSources);
private ListenableFuture<MountPointContext> createMountPointContext(final EffectiveModelContext schemaContext,
final BaseSchema baseSchema, final NetconfDeviceCommunicator listener) {
final MountPointContext emptyContext = new EmptyMountPointContext(schemaContext);
- if (!schemaContext.findModule(SchemaMountConstants.RFC8528_MODULE).isPresent()) {
+ if (schemaContext.findModule(SchemaMountConstants.RFC8528_MODULE).isEmpty()) {
return Futures.immediateFuture(emptyContext);
}
if (!errors.isEmpty()) {
LOG.warn("{}: Schema-mounts acquisition resulted in errors {}", id, errors);
}
- final NormalizedNode<?, ?> schemaMounts = rpcResult.getResult();
+ final NormalizedNode schemaMounts = rpcResult.getResult();
if (schemaMounts == null) {
LOG.debug("{}: device does not define any schema mounts", id);
return emptyContext;
}
protected NetconfDeviceRpc getDeviceSpecificRpc(final MountPointContext result,
- final RemoteDeviceCommunicator<NetconfMessage> listener) {
+ final RemoteDeviceCommunicator listener, final BaseSchema schema) {
return new NetconfDeviceRpc(result.getEffectiveModelContext(), listener,
- new NetconfMessageTransformer(result, true, baseSchemas.getBaseSchema()));
+ new NetconfMessageTransformer(result, true, schema));
}
/**
this.schemaRegistry = requireNonNull(schemaRegistry);
this.schemaRepository = requireNonNull(schemaRepository);
this.schemaContextFactory = requireNonNull(schemaContextFactory);
- this.stateSchemasResolver = requireNonNull(deviceSchemasResolver);
+ stateSchemasResolver = requireNonNull(deviceSchemasResolver);
}
public SchemaSourceRegistry getSchemaRegistry() {
SchemaSetup(final DeviceSources deviceSources, final NetconfSessionPreferences remoteSessionCapabilities) {
this.deviceSources = deviceSources;
this.remoteSessionCapabilities = remoteSessionCapabilities;
- this.capabilities = remoteSessionCapabilities.getNetconfDeviceCapabilities();
+ capabilities = remoteSessionCapabilities.getNetconfDeviceCapabilities();
// If device supports notifications and does not contain necessary modules, add them automatically
if (remoteSessionCapabilities.containsNonModuleCapability(
private QName getQNameFromSourceIdentifier(final SourceIdentifier identifier) {
// Required sources are all required and provided merged in DeviceSourcesResolver
for (final QName qname : deviceSources.getRequiredSourcesQName()) {
- if (!qname.getLocalName().equals(identifier.getName())) {
+ if (!qname.getLocalName().equals(identifier.name().getLocalName())) {
continue;
}
- if (identifier.getRevision().equals(qname.getRevision())) {
+ if (Objects.equals(identifier.revision(), qname.getRevision().orElse(null))) {
return qname;
}
}
Code Review / netconf.git / blobdiff