import akka.util.Timeout;
import java.util.List;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMNotification;
-import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDeviceSchema;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.netconf.sal.connect.netconf.sal.AbstractNetconfDataTreeService;
import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceDataBroker;
-import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceNotificationService;
import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceSalProvider;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.messages.CreateInitialMasterActorData;
private NetconfDeviceSchema currentSchema = null;
private NetconfSessionPreferences netconfSessionPreferences = null;
- private DOMRpcService deviceRpc = null;
+ private RemoteDeviceServices deviceServices = null;
private DOMDataBroker deviceDataBroker = null;
private NetconfDataTreeService netconfService = null;
- private DOMActionService deviceAction = null;
MasterSalFacade(final RemoteDeviceId id,
final ActorSystem actorSystem,
@Override
public void onDeviceConnected(final NetconfDeviceSchema deviceSchema,
- final NetconfSessionPreferences sessionPreferences,
- final DOMRpcService domRpcService, final DOMActionService domActionService) {
- deviceAction = domActionService;
- LOG.debug("{}: YANG 1.1 actions are supported in clustered netconf topology, "
- + "DOMActionService exposed for the device", id);
- onDeviceConnected(deviceSchema, sessionPreferences, domRpcService);
- }
-
- @Override
- public void onDeviceConnected(final NetconfDeviceSchema deviceSchema,
- final NetconfSessionPreferences sessionPreferences,
- final DOMRpcService domRpcService) {
+ final NetconfSessionPreferences sessionPreferences, final RemoteDeviceServices services) {
currentSchema = requireNonNull(deviceSchema);
- netconfSessionPreferences = sessionPreferences;
- deviceRpc = domRpcService;
+ netconfSessionPreferences = requireNonNull(sessionPreferences);
+ deviceServices = requireNonNull(services);
+ if (services.actions() != null) {
+ LOG.debug("{}: YANG 1.1 actions are supported in clustered netconf topology, DOMActionService exposed for "
+ + "the device", id);
+ }
LOG.info("Device {} connected - registering master mount point", id);
final var preferences = requireNonNull(netconfSessionPreferences,
"Device has no capabilities yet. Probably not fully connected.");
- final NetconfDeviceNotificationService notificationService = new NetconfDeviceNotificationService();
deviceDataBroker = newDeviceDataBroker(mountContext, preferences);
netconfService = newNetconfDataTreeService(mountContext, preferences);
final NetconfDataTreeService proxyNetconfService = new ProxyNetconfDataTreeService(id, masterActorRef,
actorSystem.dispatcher(), actorResponseWaitTime);
salProvider.getMountInstance().onTopologyDeviceConnected(mountContext.getEffectiveModelContext(),
- proxyDataBroker, proxyNetconfService, deviceRpc, notificationService, deviceAction);
+ deviceServices, proxyDataBroker, proxyNetconfService);
}
protected DOMDataBroker newDeviceDataBroker(final MountPointContext mountContext,
final NetconfSessionPreferences preferences) {
- return new NetconfDeviceDataBroker(id, mountContext, deviceRpc, preferences);
+ return new NetconfDeviceDataBroker(id, mountContext, deviceServices.rpcs(), preferences);
}
protected NetconfDataTreeService newNetconfDataTreeService(final MountPointContext mountContext,
final NetconfSessionPreferences preferences) {
- return AbstractNetconfDataTreeService.of(id, mountContext, deviceRpc, preferences);
+ return AbstractNetconfDataTreeService.of(id, mountContext, deviceServices.rpcs(), preferences);
}
private Future<Object> sendInitialDataToActor() {
// send initial data to master actor
return Patterns.ask(masterActorRef, new CreateInitialMasterActorData(deviceDataBroker, netconfService,
- sourceIdentifiers, deviceRpc, deviceAction), actorResponseWaitTime);
+ sourceIdentifiers, deviceServices.rpcs(), deviceServices.actions()), actorResponseWaitTime);
}
private void updateDeviceData() {
import akka.actor.ActorSystem;
import akka.util.Timeout;
import java.util.concurrent.atomic.AtomicBoolean;
-import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
-import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
-import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceNotificationService;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceSalProvider;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
final Timeout actorResponseWaitTime,
final DOMMountPointService mountPointService) {
this.id = id;
- this.salProvider = new NetconfDeviceSalProvider(id, mountPointService);
+ salProvider = new NetconfDeviceSalProvider(id, mountPointService);
this.actorSystem = actorSystem;
this.actorResponseWaitTime = actorResponseWaitTime;
}
- public void registerSlaveMountPoint(final EffectiveModelContext remoteSchemaContext, final DOMRpcService deviceRpc,
- final DOMActionService deviceAction, final ActorRef masterActorRef) {
+ public void registerSlaveMountPoint(final EffectiveModelContext remoteSchemaContext, final ActorRef masterActorRef,
+ final RemoteDeviceServices services) {
if (!registered.compareAndSet(false, true)) {
return;
}
- final NetconfDeviceNotificationService notificationService = new NetconfDeviceNotificationService();
final ProxyDOMDataBroker netconfDeviceDataBroker = new ProxyDOMDataBroker(id, masterActorRef,
actorSystem.dispatcher(), actorResponseWaitTime);
final NetconfDataTreeService proxyNetconfService = new ProxyNetconfDataTreeService(id, masterActorRef,
actorSystem.dispatcher(), actorResponseWaitTime);
- salProvider.getMountInstance().onTopologyDeviceConnected(remoteSchemaContext, netconfDeviceDataBroker,
- proxyNetconfService, deviceRpc, notificationService, deviceAction);
+ salProvider.getMountInstance().onTopologyDeviceConnected(remoteSchemaContext, services, netconfDeviceDataBroker,
+ proxyNetconfService);
LOG.info("{}: Slave mount point registered.", id);
}
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.ProxyDOMActionService;
import org.opendaylight.netconf.topology.singleton.impl.ProxyDOMRpcService;
final DOMMountPointService mountPointService) {
this.setup = setup;
this.id = id;
- this.schemaRegistry = setup.getSchemaResourcesDTO().getSchemaRegistry();
- this.schemaRepository = setup.getSchemaResourcesDTO().getSchemaRepository();
+ schemaRegistry = setup.getSchemaResourcesDTO().getSchemaRegistry();
+ schemaRepository = setup.getSchemaResourcesDTO().getSchemaRepository();
this.actorResponseWaitTime = actorResponseWaitTime;
- this.writeTxIdleTimeout = setup.getIdleTimeout();
+ writeTxIdleTimeout = setup.getIdleTimeout();
this.mountPointService = mountPointService;
}
public void handleReceive(final Object message) {
LOG.debug("{}: received message {}", id, message);
- if (message instanceof CreateInitialMasterActorData) { // master
- final CreateInitialMasterActorData masterActorData = (CreateInitialMasterActorData) message;
+ if (message instanceof CreateInitialMasterActorData masterActorData) { // master
sourceIdentifiers = masterActorData.getSourceIndentifiers();
- this.deviceDataBroker = masterActorData.getDeviceDataBroker();
- this.netconfService = masterActorData.getNetconfDataTreeService();
+ deviceDataBroker = masterActorData.getDeviceDataBroker();
+ netconfService = masterActorData.getNetconfDataTreeService();
final DOMDataTreeReadTransaction tx = deviceDataBroker.newReadOnlyTransaction();
readTxActor = context().actorOf(ReadTransactionActor.props(tx));
- this.deviceRpc = masterActorData.getDeviceRpc();
- this.deviceAction = masterActorData.getDeviceAction();
+ deviceRpc = masterActorData.getDeviceRpc();
+ deviceAction = masterActorData.getDeviceAction();
sender().tell(new MasterActorDataInitialized(), self());
LOG.debug("{}: Master is ready.", id);
setup = ((RefreshSetupMasterActorData) message).getNetconfTopologyDeviceSetup();
id = ((RefreshSetupMasterActorData) message).getRemoteDeviceId();
sender().tell(new MasterActorDataInitialized(), self());
- } else if (message instanceof AskForMasterMountPoint) { // master
- AskForMasterMountPoint askForMasterMountPoint = (AskForMasterMountPoint) message;
+ } else if (message instanceof AskForMasterMountPoint askForMasterMountPoint) { // master
// only master contains reference to deviceDataBroker
if (deviceDataBroker != null) {
LOG.debug("{}: Sending RegisterMountPoint reply to {}", id, askForMasterMountPoint.getSlaveActorRef());
LOG.warn("{}: Received {} but we don't appear to be the master", id, askForMasterMountPoint);
sender().tell(new Failure(new NotMasterException(self())), self());
}
- } else if (message instanceof YangTextSchemaSourceRequest) { // master
- final YangTextSchemaSourceRequest yangTextSchemaSourceRequest = (YangTextSchemaSourceRequest) message;
+ } else if (message instanceof YangTextSchemaSourceRequest yangTextSchemaSourceRequest) { // master
sendYangTextSchemaSourceProxy(yangTextSchemaSourceRequest.getSourceIdentifier(), sender());
} else if (message instanceof NewReadTransactionRequest) { // master
sender().tell(new Success(readTxActor), self());
} catch (final Exception t) {
sender().tell(new Failure(t), self());
}
- } else if (message instanceof InvokeRpcMessage) { // master
- final InvokeRpcMessage invokeRpcMessage = (InvokeRpcMessage) message;
+ } else if (message instanceof InvokeRpcMessage invokeRpcMessage) { // master
invokeSlaveRpc(invokeRpcMessage.getSchemaPath().lastNodeIdentifier(),
invokeRpcMessage.getNormalizedNodeMessage(), sender());
- } else if (message instanceof InvokeActionMessage) { // master
- final InvokeActionMessage invokeActionMessage = (InvokeActionMessage) message;
+ } else if (message instanceof InvokeActionMessage invokeActionMessage) { // master
LOG.info("InvokeActionMessage Details : {}", invokeActionMessage.toString());
invokeSlaveAction(invokeActionMessage.getSchemaPath(), invokeActionMessage.getContainerNodeMessage(),
invokeActionMessage.getDOMDataTreeIdentifier(), sender());
- } else if (message instanceof RegisterMountPoint) { //slaves
- RegisterMountPoint registerMountPoint = (RegisterMountPoint) message;
+ } else if (message instanceof RegisterMountPoint registerMountPoint) { //slaves
sourceIdentifiers = registerMountPoint.getSourceIndentifiers();
registerSlaveMountPoint(registerMountPoint.getMasterActorRef());
sender().tell(new Success(null), self());
resolveSchemaContext(createSchemaContextFactory(masterReference), slaveSalManager, masterReference, 1);
}
- private DOMRpcService getDOMRpcService(final ActorRef masterReference) {
- return new ProxyDOMRpcService(setup.getActorSystem(), masterReference, id, actorResponseWaitTime);
- }
-
- private DOMActionService getDOMActionService(final ActorRef masterReference) {
- return new ProxyDOMActionService(setup.getActorSystem(), masterReference, id, actorResponseWaitTime);
- }
-
private EffectiveModelContextFactory createSchemaContextFactory(final ActorRef masterReference) {
final RemoteYangTextSourceProvider remoteYangTextSourceProvider =
new ProxyYangTextSourceProvider(masterReference, getContext().dispatcher(), actorResponseWaitTime);
if (slaveSalManager == localSlaveSalManager) {
LOG.info("{}: Schema context resolved: {} - registering slave mount point",
id, result.getModules());
- slaveSalManager.registerSlaveMountPoint(result, getDOMRpcService(masterReference),
- getDOMActionService(masterReference), masterReference);
+ final var actorSystem = setup.getActorSystem();
+ slaveSalManager.registerSlaveMountPoint(result, masterReference, new RemoteDeviceServices(
+ new ProxyDOMRpcService(actorSystem, masterReference, id, actorResponseWaitTime),
+ new ProxyDOMActionService(actorSystem, masterReference, id, actorResponseWaitTime)));
}
});
}
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.nettyutil.ReconnectFuture;
import org.opendaylight.netconf.sal.connect.api.DeviceActionFactory;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.api.SchemaResourceManager;
import org.opendaylight.netconf.sal.connect.impl.DefaultSchemaResourceManager;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDeviceSchema;
new EmptyMountPointContext(deviceSchemaContext)),
NetconfSessionPreferences.fromStrings(
List.of(NetconfMessageTransformUtil.NETCONF_CANDIDATE_URI.toString())),
- deviceRpcService.getRpcService());
+ new RemoteDeviceServices(deviceRpcService.getRpcService(), null));
final var masterMountPoint = awaitMountPoint(masterMountPointService);
masterSalFacade.onDeviceConnected(new NetconfDeviceSchema(NetconfDeviceCapabilities.empty(),
new EmptyMountPointContext(deviceSchemaContext)), NetconfSessionPreferences.fromStrings(List.of(
NetconfMessageTransformUtil.NETCONF_CANDIDATE_URI.toString())),
- deviceRpcService.getRpcService());
+ new RemoteDeviceServices(deviceRpcService.getRpcService(), null));
verify(masterMountPointListener, timeout(5000)).onMountPointCreated(yangNodeInstanceId);
*/
package org.opendaylight.netconf.sal.connect.api;
-import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMNotification;
-import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDeviceSchema;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
/**
* When device connected, init new mount point with specific schema context and DOM services.
*
- * @param deviceSchema - {@link NetconfDeviceSchema} of connected device
- * @param sessionPreferences - session of device
- * @param deviceRpc - {@link DOMRpcService} of device
+ * @param deviceSchema {@link NetconfDeviceSchema} of connected device
+ * @param sessionPreferences session of device
+ * @param services {@link RemoteDeviceServices} available
*/
- default void onDeviceConnected(final NetconfDeviceSchema deviceSchema,
- final NetconfSessionPreferences sessionPreferences, final DOMRpcService deviceRpc) {
- // DO NOTHING
- }
-
- /**
- * When device connected, init new mount point with specific schema context and DOM services.
- *
- * @param deviceSchema - {@link NetconfDeviceSchema} of connected device
- * @param sessionPreferences - session of device
- * @param deviceRpc - {@link DOMRpcService} of device
- * @param deviceAction - {@link DOMActionService} of device
- */
- default void onDeviceConnected(final NetconfDeviceSchema deviceSchema,
- final NetconfSessionPreferences sessionPreferences,
- final DOMRpcService deviceRpc, final DOMActionService deviceAction) {
- // DO NOTHING
- }
+ void onDeviceConnected(NetconfDeviceSchema deviceSchema, NetconfSessionPreferences sessionPreferences,
+ RemoteDeviceServices services);
// FIXME: document this node
void onDeviceDisconnected();
--- /dev/null
+/*
+ * Copyright (c) 2022 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.netconf.sal.connect.api;
+
+import static java.util.Objects.requireNonNull;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.mdsal.dom.api.DOMActionService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+
+/**
+ * Set of interfaces exposed by a {@link RemoteDevice}.
+ */
+public record RemoteDeviceServices(@NonNull DOMRpcService rpcs, @Nullable DOMActionService actions) {
+ public RemoteDeviceServices {
+ requireNonNull(rpcs);
+ }
+}
import org.opendaylight.netconf.sal.connect.api.RemoteDevice;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
resolveBaseSchema(remoteSessionCapabilities.isNotificationsSupported()));
// salFacade.onDeviceConnected has to be called before the notification handler is initialized
- salFacade.onDeviceConnected(deviceSchema, remoteSessionCapabilities, deviceRpc,
- deviceActionFactory == null ? null : deviceActionFactory.createDeviceAction(
- messageTransformer, listener, mount.getEffectiveModelContext()));
+ salFacade.onDeviceConnected(deviceSchema, remoteSessionCapabilities,
+ new RemoteDeviceServices(deviceRpc, deviceActionFactory == null ? null
+ : deviceActionFactory.createDeviceAction(messageTransformer, listener,
+ mount.getEffectiveModelContext())));
notificationHandler.onRemoteSchemaUp(messageTransformer);
LOG.info("{}: Netconf connector initialized successfully", id);
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.sal.connect.api.RemoteDevice;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
@Override
public void onRemoteSessionUp(final NetconfSessionPreferences remoteSessionCapabilities,
final NetconfDeviceCommunicator netconfDeviceCommunicator) {
- final SchemalessNetconfDeviceRpc schemalessNetconfDeviceRpc = new SchemalessNetconfDeviceRpc(id,
- netconfDeviceCommunicator, rpcTransformer, messageTransformer);
-
salFacade.onDeviceConnected(
// FIXME: or bound from base schema rather?
new NetconfDeviceSchema(NetconfDeviceCapabilities.empty(),
baseSchemas.getBaseSchema().getMountPointContext()),
- remoteSessionCapabilities, schemalessNetconfDeviceRpc);
+ remoteSessionCapabilities, new RemoteDeviceServices(
+ new SchemalessNetconfDeviceRpc(id,netconfDeviceCommunicator, rpcTransformer, messageTransformer),
+ null));
}
@Override
import java.util.concurrent.TimeUnit;
import org.checkerframework.checker.lock.qual.GuardedBy;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDeviceSchema;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
private final RemoteDeviceId id;
private volatile NetconfDeviceCommunicator listener;
- private volatile DOMRpcService currentDeviceRpc;
+ private volatile RemoteDeviceServices currentServices;
public KeepaliveSalFacade(final RemoteDeviceId id, final RemoteDeviceHandler salFacade,
final ScheduledExecutorService executor, final long keepaliveDelaySeconds,
*/
private synchronized void stopKeepalives() {
keepaliveTask.disableKeepalive();
- currentDeviceRpc = null;
+ currentServices = null;
}
void reconnect() {
@Override
public void onDeviceConnected(final NetconfDeviceSchema deviceSchema,
- final NetconfSessionPreferences netconfSessionPreferences, final DOMRpcService deviceRpc) {
- onDeviceConnected(deviceSchema, netconfSessionPreferences, deviceRpc, null);
- }
+ final NetconfSessionPreferences sessionPreferences, final RemoteDeviceServices services) {
+ currentServices = requireNonNull(services);
- @Override
- public void onDeviceConnected(final NetconfDeviceSchema deviceSchema,
- final NetconfSessionPreferences netconfSessionPreferences, final DOMRpcService deviceRpc,
- final DOMActionService deviceAction) {
- currentDeviceRpc = requireNonNull(deviceRpc);
- salFacade.onDeviceConnected(deviceSchema, netconfSessionPreferences,
- new KeepaliveDOMRpcService(deviceRpc), deviceAction);
+ final var devAction = services.actions();
+ // FIXME: wrap with keepalive
+ final var kaAction = devAction;
+
+ salFacade.onDeviceConnected(deviceSchema, sessionPreferences,
+ new RemoteDeviceServices(new KeepaliveDOMRpcService(services.rpcs()), kaAction));
LOG.debug("{}: Netconf session initiated, starting keepalives", id);
LOG.trace("{}: Scheduling keepalives every {}s", id, keepaliveDelaySeconds);
return;
}
- final var deviceRpc = currentDeviceRpc;
- if (deviceRpc == null) {
+ final var localServices = currentServices;
+ if (localServices == null) {
// deviceRpc is null, which means we hit the reconnect window and attempted to send keepalive while
// we were reconnecting. Next keepalive will be scheduled after reconnect so no action necessary here.
LOG.debug("{}: Skipping keepalive while reconnecting", id);
}
LOG.trace("{}: Invoking keepalive RPC", id);
- final var deviceFuture = deviceRpc.invokeRpc(NETCONF_GET_CONFIG_QNAME, KEEPALIVE_PAYLOAD);
+ final var deviceFuture = localServices.rpcs().invokeRpc(NETCONF_GET_CONFIG_QNAME, KEEPALIVE_PAYLOAD);
lastActivity = now;
Futures.addCallback(deviceFuture, this, MoreExecutors.directExecutor());
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMNotification;
-import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDeviceSchema;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public synchronized void onDeviceConnected(final NetconfDeviceSchema deviceSchema,
- final NetconfSessionPreferences sessionPreferences, final DOMRpcService deviceRpc,
- final DOMActionService deviceAction) {
- final MountPointContext mountContext = deviceSchema.mountContext();
- final EffectiveModelContext schemaContext = mountContext.getEffectiveModelContext();
-
- final NetconfDeviceDataBroker netconfDeviceDataBroker =
- new NetconfDeviceDataBroker(id, mountContext, deviceRpc, sessionPreferences);
- final NetconfDataTreeService netconfService =
- AbstractNetconfDataTreeService.of(id, mountContext, deviceRpc, sessionPreferences);
- registerLockListener(netconfDeviceDataBroker, netconfService);
- final NetconfDeviceNotificationService notificationService = new NetconfDeviceNotificationService();
-
- salProvider.getMountInstance().onTopologyDeviceConnected(schemaContext, netconfDeviceDataBroker, netconfService,
- deviceRpc, notificationService, deviceAction);
+ final NetconfSessionPreferences sessionPreferences, final RemoteDeviceServices services) {
+ final var mountContext = deviceSchema.mountContext();
+ final var modelContext = mountContext.getEffectiveModelContext();
+
+ final var deviceRpc = services.rpcs();
+ // FIXME: instanceof DOMRpcService, as it might be others
+ final var netconfDataBroker = new NetconfDeviceDataBroker(id, mountContext, deviceRpc, sessionPreferences);
+ final var netconfDataTree = AbstractNetconfDataTreeService.of(id, mountContext, deviceRpc, sessionPreferences);
+ registerLockListener(netconfDataBroker, netconfDataTree);
+
+ salProvider.getMountInstance().onTopologyDeviceConnected(modelContext, services, netconfDataBroker,
+ netconfDataTree);
salProvider.getTopologyDatastoreAdapter().updateDeviceData(true, deviceSchema.capabilities());
}
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.dom.spi.FixedDOMSchemaService;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
this.id = requireNonNull(id);
}
+ public void onTopologyDeviceConnected(final EffectiveModelContext initialCtx,
+ final RemoteDeviceServices services, final DOMDataBroker broker,
+ final NetconfDataTreeService dataTreeService) {
+ onTopologyDeviceConnected(initialCtx, services, new NetconfDeviceNotificationService(), broker,
+ dataTreeService);
+ }
+
public synchronized void onTopologyDeviceConnected(final EffectiveModelContext initialCtx,
- final DOMDataBroker broker, final NetconfDataTreeService netconfService, final DOMRpcService rpc,
- final NetconfDeviceNotificationService newNotificationService, final DOMActionService deviceAction) {
+ final RemoteDeviceServices services, final NetconfDeviceNotificationService newNotificationService,
+ final DOMDataBroker broker, final NetconfDataTreeService dataTreeService) {
requireNonNull(mountService, "Closed");
checkState(topologyRegistration == null, "Already initialized");
if (broker != null) {
mountBuilder.addService(DOMDataBroker.class, broker);
}
- mountBuilder.addService(DOMRpcService.class, rpc);
- mountBuilder.addService(DOMNotificationService.class, newNotificationService);
- if (deviceAction != null) {
- mountBuilder.addService(DOMActionService.class, deviceAction);
+ mountBuilder.addService(DOMRpcService.class, services.rpcs());
+ final var actions = services.actions();
+ if (actions != null) {
+ mountBuilder.addService(DOMActionService.class, actions);
}
- if (netconfService != null) {
- mountBuilder.addService(NetconfDataTreeService.class, netconfService);
+ if (dataTreeService != null) {
+ mountBuilder.addService(NetconfDataTreeService.class, dataTreeService);
}
+ mountBuilder.addService(DOMNotificationService.class, newNotificationService);
notificationService = newNotificationService;
topologyRegistration = mountBuilder.register();
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyCollection;
import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.after;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doNothing;
import java.util.concurrent.Executors;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
-import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.sal.connect.api.MessageTransformer;
import org.opendaylight.netconf.sal.connect.api.NetconfDeviceSchemasResolver;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
-import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceRpc;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability;
device.onRemoteSessionUp(sessionCaps, listener);
verify(facade, timeout(5000)).onDeviceConnected(any(NetconfDeviceSchema.class),
- any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class), isNull());
+ any(NetconfSessionPreferences.class), any(RemoteDeviceServices.class));
verify(schemaFactory, times(2)).createEffectiveModelContext(anyCollection());
}
.build();
// Monitoring supported
final NetconfSessionPreferences sessionCaps =
- getSessionCaps(true, Lists.newArrayList(TEST_CAPABILITY, TEST_CAPABILITY2));
+ getSessionCaps(true, List.of(TEST_CAPABILITY, TEST_CAPABILITY2));
device.onRemoteSessionUp(sessionCaps, listener);
verify(facade, timeout(5000)).onDeviceConnected(any(NetconfDeviceSchema.class),
- any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class), isNull());
+ any(NetconfSessionPreferences.class), any(RemoteDeviceServices.class));
verify(schemaFactory, times(1)).createEffectiveModelContext(anyCollection());
}
verify(schemaContextProviderFactory, timeout(5000)).createEffectiveModelContext(any(Collection.class));
verify(facade, timeout(5000)).onDeviceConnected(
- any(NetconfDeviceSchema.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class),
- isNull());
+ any(NetconfDeviceSchema.class), any(NetconfSessionPreferences.class), any(RemoteDeviceServices.class));
device.onRemoteSessionDown();
verify(facade, timeout(5000)).onDeviceDisconnected();
verify(schemaContextProviderFactory, timeout(5000).times(2)).createEffectiveModelContext(any(Collection.class));
verify(facade, timeout(5000).times(2)).onDeviceConnected(
- any(NetconfDeviceSchema.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class),
- isNull());
+ any(NetconfDeviceSchema.class), any(NetconfSessionPreferences.class), any(RemoteDeviceServices.class));
}
@Test
//complete schema setup
schemaFuture.set(SCHEMA_CONTEXT);
//facade.onDeviceDisconnected() was called, so facade.onDeviceConnected() shouldn't be called anymore
- verify(facade, after(1000).never()).onDeviceConnected(any(), any(), any(), any(DOMActionService.class));
+ verify(facade, after(1000).never()).onDeviceConnected(any(), any(), any(RemoteDeviceServices.class));
}
@Test
final ArgumentCaptor<NetconfDeviceSchema> argument = ArgumentCaptor.forClass(NetconfDeviceSchema.class);
verify(facade, timeout(5000)).onDeviceConnected(argument.capture(), any(NetconfSessionPreferences.class),
- any(DOMRpcService.class), isNull());
+ any(RemoteDeviceServices.class));
argument.getValue().capabilities().resolvedCapabilities()
.forEach(entry -> assertEquals("Builded 'AvailableCapability' schemas should match input capabilities.",
moduleBasedCaps.get(
final ArgumentCaptor<NetconfDeviceSchema> argument = ArgumentCaptor.forClass(NetconfDeviceSchema.class);
verify(facade, timeout(5000)).onDeviceConnected(argument.capture(), any(NetconfSessionPreferences.class),
- any(DOMRpcService.class), isNull());
+ any(RemoteDeviceServices.class));
List<String> notificationModulesName = Arrays.asList(
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
final ArgumentCaptor<NetconfDeviceSchema> argument = ArgumentCaptor.forClass(NetconfDeviceSchema.class);
verify(facade, timeout(5000)).onDeviceConnected(argument.capture(), any(NetconfSessionPreferences.class),
- any(DOMRpcService.class), isNull());
+ any(RemoteDeviceServices.class));
final NetconfDeviceCapabilities netconfDeviceCaps = argument.getValue().capabilities();
List<String> notificationModulesName = List.of(
final ArgumentCaptor<NetconfDeviceSchema> argument = ArgumentCaptor.forClass(NetconfDeviceSchema.class);
verify(facade, timeout(5000)).onDeviceConnected(argument.capture(), any(NetconfSessionPreferences.class),
- any(DOMRpcService.class), isNull());
+ any(RemoteDeviceServices.class));
final Set<AvailableCapability> resolvedCapabilities = argument.getValue().capabilities().resolvedCapabilities();
- List<String> notificationModulesName = Arrays.asList(
+ List<String> notificationModulesName = List.of(
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714
.$YangModuleInfoImpl.getInstance().getName().toString(),
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
private static RemoteDeviceHandler getFacade() throws Exception {
final RemoteDeviceHandler remoteDeviceHandler = mockCloseableClass(RemoteDeviceHandler.class);
doNothing().when(remoteDeviceHandler).onDeviceConnected(
- any(NetconfDeviceSchema.class), any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class),
- any(DOMActionService.class));
+ any(NetconfDeviceSchema.class), any(NetconfSessionPreferences.class), any(RemoteDeviceServices.class));
doNothing().when(remoteDeviceHandler).onDeviceDisconnected();
doNothing().when(remoteDeviceHandler).onNotification(any(DOMNotification.class));
return remoteDeviceHandler;
import org.junit.Test;
import org.mockito.Mockito;
import org.opendaylight.mdsal.dom.api.DOMNotification;
-import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
-import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceRpc;
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.SchemalessMessageTransformer;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
device.onRemoteSessionUp(sessionCaps, listener);
verify(facade).onDeviceConnected(
- any(NetconfDeviceSchema.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class));
+ any(NetconfDeviceSchema.class), any(NetconfSessionPreferences.class), any(RemoteDeviceServices.class));
device.onNotification(netconfMessage);
verify(facade).onNotification(isNull());
private static RemoteDeviceHandler getFacade() throws Exception {
final RemoteDeviceHandler remoteDeviceHandler = mockCloseableClass(RemoteDeviceHandler.class);
doNothing().when(remoteDeviceHandler).onDeviceConnected(
- any(NetconfDeviceSchema.class), any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class));
+ any(NetconfDeviceSchema.class), any(NetconfSessionPreferences.class), any(RemoteDeviceServices.class));
doNothing().when(remoteDeviceHandler).onDeviceDisconnected();
doNothing().when(remoteDeviceHandler).onNotification(any(DOMNotification.class));
return remoteDeviceHandler;
*/
package org.opendaylight.netconf.sal.connect.netconf.sal;
+import static java.util.Objects.requireNonNull;
import static org.mockito.Mockito.after;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDeviceSchema;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_RUNNING_NODEID)
.build()));
- keepaliveSalFacade.onDeviceConnected(null, null, deviceRpc);
+ keepaliveSalFacade.onDeviceConnected(null, null, new RemoteDeviceServices(deviceRpc, null));
//Invoke general RPC on simulated local facade without args (or with null args). Will be returned
//settableFuture variable without any set value. WaitingShaduler in keepalive sal facade should wait for any
}
private static final class LocalNetconfSalFacade implements RemoteDeviceHandler {
- private DOMRpcService localDeviceRpc;
+ private volatile RemoteDeviceServices currentServices;
@Override
public void onDeviceConnected(final NetconfDeviceSchema deviceSchema,
- final NetconfSessionPreferences netconfSessionPreferences, final DOMRpcService currentDeviceRpc,
- final DOMActionService deviceAction) {
- localDeviceRpc = currentDeviceRpc;
+ final NetconfSessionPreferences sessionPreferences, final RemoteDeviceServices services) {
+ currentServices = requireNonNull(services);
}
@Override
public void onDeviceDisconnected() {
+ currentServices = null;
}
@Override
}
public void invokeNullRpc() {
- if (localDeviceRpc != null) {
- localDeviceRpc.invokeRpc(null, null);
+ final var local = currentServices;
+ if (local != null) {
+ local.rpcs().invokeRpc(null, null);
}
}
}
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
executorServiceSpy = Executors.newScheduledThreadPool(1);
doNothing().when(listener).disconnect();
- doNothing().when(underlyingSalFacade).onDeviceConnected(isNull(), isNull(), any(DOMRpcService.class), isNull());
+ doNothing().when(underlyingSalFacade).onDeviceConnected(isNull(), isNull(), any(RemoteDeviceServices.class));
keepaliveSalFacade =
new KeepaliveSalFacade(REMOTE_DEVICE_ID, underlyingSalFacade, executorServiceSpy, 1L, 1L);
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_RUNNING_NODEID)
.build()))).when(deviceRpc).invokeRpc(any(QName.class), any(ContainerNode.class));
- keepaliveSalFacade.onDeviceConnected(null, null, deviceRpc);
+ final var services = new RemoteDeviceServices(deviceRpc, null);
+ keepaliveSalFacade.onDeviceConnected(null, null, services);
- verify(underlyingSalFacade).onDeviceConnected(
- isNull(), isNull(), any(DOMRpcService.class), isNull());
+ verify(underlyingSalFacade).onDeviceConnected(isNull(), isNull(), any(RemoteDeviceServices.class));
verify(deviceRpc, timeout(15000).times(5)).invokeRpc(any(QName.class), any(ContainerNode.class));
}
doReturn(FluentFutures.immediateFailedFluentFuture(new IllegalStateException("illegal-state")))
.when(deviceRpc).invokeRpc(any(QName.class), any(ContainerNode.class));
- keepaliveSalFacade.onDeviceConnected(null, null, deviceRpc);
+ keepaliveSalFacade.onDeviceConnected(null, null, new RemoteDeviceServices(deviceRpc, null));
- verify(underlyingSalFacade).onDeviceConnected(isNull(), isNull(), any(DOMRpcService.class), isNull());
+ verify(underlyingSalFacade).onDeviceConnected(isNull(), isNull(), any(RemoteDeviceServices.class));
// Should disconnect the session
verify(listener, timeout(15000).times(1)).disconnect();
@Test
public void testKeepaliveSuccessWithRpcError() {
- final DOMRpcResult rpcSuccessWithError = new DefaultDOMRpcResult(mock(RpcError.class));
+ final var rpcSuccessWithError = new DefaultDOMRpcResult(mock(RpcError.class));
doReturn(FluentFutures.immediateFluentFuture(rpcSuccessWithError))
.when(deviceRpc).invokeRpc(any(QName.class), any(ContainerNode.class));
- keepaliveSalFacade.onDeviceConnected(null, null, deviceRpc);
-
- verify(underlyingSalFacade).onDeviceConnected(isNull(), isNull(), any(DOMRpcService.class), isNull());
+ keepaliveSalFacade.onDeviceConnected(null, null, new RemoteDeviceServices(deviceRpc, null));
+ verify(underlyingSalFacade).onDeviceConnected(isNull(), isNull(), any(RemoteDeviceServices.class));
// Shouldn't disconnect the session
verify(listener, times(0)).disconnect();
@Test
public void testNonKeepaliveRpcFailure() throws Exception {
- doAnswer(invocation -> proxyRpc = invocation.getArgument(2))
- .when(underlyingSalFacade).onDeviceConnected(isNull(), isNull(), any(DOMRpcService.class), isNull());
+ doAnswer(invocation -> proxyRpc = invocation.getArgument(2, RemoteDeviceServices.class).rpcs())
+ .when(underlyingSalFacade).onDeviceConnected(isNull(), isNull(), any(RemoteDeviceServices.class));
doReturn(FluentFutures.immediateFailedFluentFuture(new IllegalStateException("illegal-state")))
.when(deviceRpc).invokeRpc(any(QName.class), any(ContainerNode.class));
new KeepaliveSalFacade(REMOTE_DEVICE_ID, underlyingSalFacade, executorServiceSpy, 100L, 1L);
keepaliveSalFacade.setListener(listener);
- keepaliveSalFacade.onDeviceConnected(null, null, deviceRpc);
+ keepaliveSalFacade.onDeviceConnected(null, null, new RemoteDeviceServices(deviceRpc, null));
proxyRpc.invokeRpc(QName.create("foo", "bar"), mock(ContainerNode.class));
import static org.mockito.Mockito.when;
import java.net.InetSocketAddress;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfService;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
@Test
public void testOnTopologyDeviceConnected() {
- mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, broker, null, rpcService,
- notificationService, null);
+ mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, new RemoteDeviceServices(rpcService, null),
+ notificationService, broker, null);
verify(mountPointBuilder).addService(eq(DOMSchemaService.class), any());
verify(mountPointBuilder).addService(DOMDataBroker.class, broker);
verify(mountPointBuilder).addService(DOMRpcService.class, rpcService);
@Test
public void testOnTopologyDeviceConnectedWithNetconfService() {
- mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, null, netconfService, rpcService,
- notificationService, null);
+ mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, new RemoteDeviceServices(rpcService, null),
+ notificationService, null, netconfService);
verify(mountPointBuilder).addService(eq(DOMSchemaService.class), any());
verify(mountPointBuilder).addService(NetconfDataTreeService.class, netconfService);
verify(mountPointBuilder).addService(DOMRpcService.class, rpcService);
@Test
public void testOnTopologyDeviceDisconnected() {
- mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, broker, null, rpcService,
- notificationService, null);
+ mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, new RemoteDeviceServices(rpcService, null),
+ notificationService, broker, null);
mountInstance.onTopologyDeviceDisconnected();
verify(registration).close();
- try {
- mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, broker, null, rpcService,
- notificationService, null);
- } catch (final IllegalStateException e) {
- LOG.warn("Operation failed.", e);
- Assert.fail("Topology registration still present after disconnect ");
- }
+ mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, new RemoteDeviceServices(rpcService, null),
+ notificationService, broker, null);
}
@Test
public void testClose() {
- mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, broker, null, rpcService,
- notificationService, null);
+ mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, new RemoteDeviceServices(rpcService, null),
+ notificationService, broker, null);
mountInstance.close();
verify(registration).close();
}
@Test
public void testPublishNotification() {
- mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, broker, null, rpcService,
- notificationService, null);
+ mountInstance.onTopologyDeviceConnected(SCHEMA_CONTEXT, new RemoteDeviceServices(rpcService, null),
+ notificationService, broker, null);
verify(mountPointBuilder).addService(eq(DOMSchemaService.class), any());
verify(mountPointBuilder).addService(DOMNotificationService.class, notificationService);
mountInstance.publish(notification);
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
+import org.opendaylight.netconf.sal.connect.api.RemoteDeviceServices;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDeviceSchema;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
final var netconfSessionPreferences = NetconfSessionPreferences.fromStrings(
List.of(NetconfMessageTransformUtil.NETCONF_CANDIDATE_URI.toString()));
- final DOMRpcService deviceRpc = mock(DOMRpcService.class);
+ final var deviceServices = new RemoteDeviceServices(mock(DOMRpcService.class), null);
deviceFacade.onDeviceConnected(
new NetconfDeviceSchema(NetconfDeviceCapabilities.empty(), new EmptyMountPointContext(schemaContext)),
- netconfSessionPreferences, deviceRpc, null);
+ netconfSessionPreferences, deviceServices);
verifyConnectionStatusUpdate(ConnectionStatus.Connected);
- verify(mountInstance, times(1)).onTopologyDeviceConnected(eq(schemaContext),
- any(DOMDataBroker.class), any(NetconfDataTreeService.class), eq(deviceRpc),
- any(NetconfDeviceNotificationService.class), isNull());
+ verify(mountInstance, times(1)).onTopologyDeviceConnected(eq(schemaContext), eq(deviceServices),
+ any(DOMDataBroker.class), any(NetconfDataTreeService.class));
}
@Test