import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.topology.AbstractNetconfTopology;
import org.opendaylight.netconf.topology.api.SchemaRepositoryProvider;
protected DOMMountPointService mountPointService = null;
- BaseCallHomeTopology(String topologyId, NetconfClientDispatcher clientDispatcher,
- BindingAwareBroker bindingAwareBroker,
- Broker domBroker,
- EventExecutor eventExecutor,
- ScheduledThreadPool keepaliveExecutor,
- ThreadPool processingExecutor,
- SchemaRepositoryProvider schemaRepositoryProvider,
- DataBroker dataBroker,
- DOMMountPointService mountPointService) {
- super(topologyId, clientDispatcher, bindingAwareBroker, domBroker, eventExecutor, keepaliveExecutor,
- processingExecutor, schemaRepositoryProvider, dataBroker);
+ BaseCallHomeTopology(final String topologyId, final NetconfClientDispatcher clientDispatcher,
+ final EventExecutor eventExecutor,
+ final ScheduledThreadPool keepaliveExecutor,
+ final ThreadPool processingExecutor,
+ final SchemaRepositoryProvider schemaRepositoryProvider,
+ final DataBroker dataBroker,
+ final DOMMountPointService mountPointService) {
+ super(topologyId, clientDispatcher, eventExecutor, keepaliveExecutor,
+ processingExecutor, schemaRepositoryProvider, dataBroker, mountPointService);
this.mountPointService = mountPointService;
}
}
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.netconf.callhome.mount.CallHomeMountSessionContext.CloseCallback;
import org.opendaylight.netconf.callhome.protocol.CallHomeChannelActivator;
import org.opendaylight.netconf.callhome.protocol.CallHomeNetconfSubsystemListener;
private final static Logger LOG = LoggerFactory.getLogger(CallHomeMountDispatcher.class);
private final String topologyId;
- private final BindingAwareBroker bindingAwareBroker;
private final EventExecutor eventExecutor;
private final ScheduledThreadPool keepaliveExecutor;
private final ThreadPool processingExecutor;
private final SchemaRepositoryProvider schemaRepositoryProvider;
- private final org.opendaylight.controller.sal.core.api.Broker domBroker;
private final CallHomeMountSessionManager sessionManager;
private final DataBroker dataBroker;
private final DOMMountPointService mountService;
private final CloseCallback onCloseHandler = new CloseCallback() {
@Override
- public void onClosed(CallHomeMountSessionContext deviceContext) {
+ public void onClosed(final CallHomeMountSessionContext deviceContext) {
LOG.info("Removing {} from Netconf Topology.", deviceContext.getId());
topology.disconnectNode(deviceContext.getId());
}
};
- public CallHomeMountDispatcher(String topologyId, BindingAwareBroker bindingAwareBroker,
- EventExecutor eventExecutor,
- ScheduledThreadPool keepaliveExecutor,
- ThreadPool processingExecutor,
- SchemaRepositoryProvider schemaRepositoryProvider,
- Broker domBroker, DataBroker dataBroker,
- DOMMountPointService mountService) {
+ public CallHomeMountDispatcher(final String topologyId,
+ final EventExecutor eventExecutor,
+ final ScheduledThreadPool keepaliveExecutor,
+ final ThreadPool processingExecutor,
+ final SchemaRepositoryProvider schemaRepositoryProvider,
+ final DataBroker dataBroker,
+ final DOMMountPointService mountService) {
this.topologyId = topologyId;
- this.bindingAwareBroker = bindingAwareBroker;
this.eventExecutor = eventExecutor;
this.keepaliveExecutor = keepaliveExecutor;
this.processingExecutor = processingExecutor;
this.schemaRepositoryProvider = schemaRepositoryProvider;
- this.domBroker = domBroker;
this.sessionManager = new CallHomeMountSessionManager();
this.dataBroker = dataBroker;
this.mountService = mountService;
}
@Override
- public Future<NetconfClientSession> createClient(NetconfClientConfiguration clientConfiguration) {
+ public Future<NetconfClientSession> createClient(final NetconfClientConfiguration clientConfiguration) {
return activateChannel(clientConfiguration);
}
@Override
- public Future<Void> createReconnectingClient(NetconfReconnectingClientConfiguration clientConfiguration) {
+ public Future<Void> createReconnectingClient(final NetconfReconnectingClientConfiguration clientConfiguration) {
return activateChannel(clientConfiguration);
}
- private <V> Future<V> activateChannel(NetconfClientConfiguration conf) {
- InetSocketAddress remoteAddr = conf.getAddress();
- CallHomeMountSessionContext context = getSessionManager().getByAddress(remoteAddr);
+ private <V> Future<V> activateChannel(final NetconfClientConfiguration conf) {
+ final InetSocketAddress remoteAddr = conf.getAddress();
+ final CallHomeMountSessionContext context = getSessionManager().getByAddress(remoteAddr);
LOG.info("Activating NETCONF channel for ip {} device context {}", remoteAddr, context);
if (context == null) {
return new FailedFuture<>(eventExecutor, new NullPointerException());
}
void createTopology() {
- this.topology = new CallHomeTopology(topologyId, this, bindingAwareBroker, domBroker, eventExecutor,
+ this.topology = new CallHomeTopology(topologyId, this, eventExecutor,
keepaliveExecutor, processingExecutor, schemaRepositoryProvider, dataBroker, mountService);
}
@Override
- public void onNetconfSubsystemOpened(CallHomeProtocolSessionContext session,
- CallHomeChannelActivator activator) {
- CallHomeMountSessionContext deviceContext = getSessionManager().createSession(session, activator, onCloseHandler);
- NodeId nodeId = deviceContext.getId();
- Node configNode = deviceContext.getConfigNode();
+ public void onNetconfSubsystemOpened(final CallHomeProtocolSessionContext session,
+ final CallHomeChannelActivator activator) {
+ final CallHomeMountSessionContext deviceContext = getSessionManager().createSession(session, activator, onCloseHandler);
+ final NodeId nodeId = deviceContext.getId();
+ final Node configNode = deviceContext.getConfigNode();
LOG.info("Provisioning fake config {}", configNode);
topology.connectNode(nodeId, configNode);
}
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
public class CallHomeTopology extends BaseCallHomeTopology {
- public CallHomeTopology(String topologyId, NetconfClientDispatcher clientDispatcher,
- BindingAwareBroker bindingAwareBroker,
- Broker domBroker, EventExecutor eventExecutor,
- ScheduledThreadPool keepaliveExecutor, ThreadPool processingExecutor,
- SchemaRepositoryProvider schemaRepositoryProvider,
- DataBroker dataBroker, DOMMountPointService mountPointService) {
- super(topologyId, clientDispatcher, bindingAwareBroker, domBroker, eventExecutor,
+ public CallHomeTopology(final String topologyId, final NetconfClientDispatcher clientDispatcher,
+ final EventExecutor eventExecutor,
+ final ScheduledThreadPool keepaliveExecutor, final ThreadPool processingExecutor,
+ final SchemaRepositoryProvider schemaRepositoryProvider,
+ final DataBroker dataBroker, final DOMMountPointService mountPointService) {
+ super(topologyId, clientDispatcher, eventExecutor,
keepaliveExecutor, processingExecutor, schemaRepositoryProvider,
dataBroker, mountPointService);
}
@Override
- protected RemoteDeviceHandler<NetconfSessionPreferences> createSalFacade(RemoteDeviceId id,
- Broker domBroker,
- BindingAwareBroker bindingBroker) {
- return new NetconfDeviceSalFacade(id, domBroker, bindingAwareBroker);
+ protected RemoteDeviceHandler<NetconfSessionPreferences> createSalFacade(final RemoteDeviceId id) {
+ return new NetconfDeviceSalFacade(id, mountPointService, dataBroker);
}
}
xmlns:odl="http://opendaylight.org/xmlns/blueprint/v1.0.0"
odl:use-default-for-reference-types="true">
- <reference id="bindingAwareBroker"
- interface="org.opendaylight.controller.sal.binding.api.BindingAwareBroker"/>
<reference id="keepAliveExecutor"
interface="org.opendaylight.controller.config.threadpool.ScheduledThreadPool"
odl:type="global-netconf-ssh-scheduled-executor"/>
<reference id="processingExecutor"
interface="org.opendaylight.controller.config.threadpool.ThreadPool"
odl:type="global-netconf-processing-executor"/>
- <reference id="domBroker"
- interface="org.opendaylight.controller.sal.core.api.Broker"/>
<reference id="eventExecutor"
interface="io.netty.util.concurrent.EventExecutor"
odl:type="global-event-executor"/>
<bean id="callhomeDispatcher" class="org.opendaylight.netconf.callhome.mount.CallHomeMountDispatcher">
<argument value="topology-netconf"/>
- <argument ref="bindingAwareBroker"/>
<argument ref="eventExecutor"/>
<argument ref="keepAliveExecutor"/>
<argument ref="processingExecutor"/>
<argument ref="schemaRepository"/>
- <argument ref="domBroker"/>
<argument ref="dataBroker"/>
<argument ref="domMountPointService"/>
</bean>
import static org.junit.Assert.assertFalse;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import io.netty.util.concurrent.Future;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
-
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.callhome.protocol.CallHomeChannelActivator;
import org.opendaylight.netconf.callhome.protocol.CallHomeProtocolSessionContext;
public class CallHomeMountDispatcherTest {
private String topologyId;
- private BindingAwareBroker mockBroker;
private EventExecutor mockExecutor;
private ScheduledThreadPool mockKeepAlive;
private ThreadPool mockProcessingExecutor;
private SchemaRepositoryProvider mockSchemaRepoProvider;
- private Broker mockDomBroker;
private CallHomeMountDispatcher instance;
private DataBroker mockDataBroker;
@Before
public void setup() {
topologyId = "";
- mockBroker = mock(BindingAwareBroker.class);
mockExecutor = mock(EventExecutor.class);
mockKeepAlive = mock(ScheduledThreadPool.class);
mockProcessingExecutor = mock(ThreadPool.class);
mockSchemaRepoProvider = mock(SchemaRepositoryProvider.class);
- mockDomBroker = mock(Broker.class);
mockDataBroker = mock(DataBroker.class);
mockMount = mock(DOMMountPointService.class);
mockSessMgr = mock(CallHomeMountSessionManager.class);
mockTopology = mock(CallHomeTopology.class);
mockProtoSess = mock(CallHomeProtocolSessionContext.class);
- instance = new CallHomeMountDispatcher(topologyId, mockBroker, mockExecutor, mockKeepAlive,
- mockProcessingExecutor, mockSchemaRepoProvider, mockDomBroker, mockDataBroker, mockMount) {
+ instance = new CallHomeMountDispatcher(topologyId, mockExecutor, mockKeepAlive,
+ mockProcessingExecutor, mockSchemaRepoProvider, mockDataBroker, mockMount) {
@Override
public CallHomeMountSessionManager getSessionManager() {
return mockSessMgr;
};
}
- NetconfClientConfiguration someConfiguration(InetSocketAddress address) {
+ NetconfClientConfiguration someConfiguration(final InetSocketAddress address) {
// NetconfClientConfiguration has mostly final methods, making it un-mock-able
- NetconfClientConfiguration.NetconfClientProtocol protocol =
+ final NetconfClientConfiguration.NetconfClientProtocol protocol =
NetconfClientConfiguration.NetconfClientProtocol.SSH;
- NetconfHelloMessageAdditionalHeader additionalHeader = mock(NetconfHelloMessageAdditionalHeader.class);
- NetconfClientSessionListener sessionListener = mock(NetconfClientSessionListener.class);
- ReconnectStrategy reconnectStrategy = mock(ReconnectStrategy.class);
- AuthenticationHandler authHandler = mock(AuthenticationHandler.class);
+ final NetconfHelloMessageAdditionalHeader additionalHeader = mock(NetconfHelloMessageAdditionalHeader.class);
+ final NetconfClientSessionListener sessionListener = mock(NetconfClientSessionListener.class);
+ final ReconnectStrategy reconnectStrategy = mock(ReconnectStrategy.class);
+ final AuthenticationHandler authHandler = mock(AuthenticationHandler.class);
return NetconfClientConfigurationBuilder.create().withProtocol(protocol).withAddress(address)
.withConnectionTimeoutMillis(0).withAdditionalHeader(additionalHeader)
@Test
public void canCreateASessionFromAConfiguration() {
// given
- CallHomeMountSessionContext mockContext = mock(CallHomeMountSessionContext.class);
- InetSocketAddress someAddress = InetSocketAddress.createUnresolved("1.2.3.4", 123);
+ final CallHomeMountSessionContext mockContext = mock(CallHomeMountSessionContext.class);
+ final InetSocketAddress someAddress = InetSocketAddress.createUnresolved("1.2.3.4", 123);
doReturn(mockContext).when(mockSessMgr).getByAddress(eq(someAddress));
- NetconfClientConfiguration someCfg = someConfiguration(someAddress);
+ final NetconfClientConfiguration someCfg = someConfiguration(someAddress);
// when
instance.createClient(someCfg);
// then
@Test
public void noSessionIsCreatedWithoutAContextAvailableForAGivenAddress() {
// given
- InetSocketAddress someAddress = InetSocketAddress.createUnresolved("1.2.3.4", 123);
- NetconfClientConfiguration someCfg = someConfiguration(someAddress);
+ final InetSocketAddress someAddress = InetSocketAddress.createUnresolved("1.2.3.4", 123);
+ final NetconfClientConfiguration someCfg = someConfiguration(someAddress);
// when
- Future<NetconfClientSession> future = instance.createClient(someCfg);
+ final Future<NetconfClientSession> future = instance.createClient(someCfg);
// then
assertFalse(future.isSuccess());
}
@Test
public void nodeIsInsertedIntoTopologyWhenSubsystemIsOpened() throws UnknownHostException {
// given
- NodeId mockNodeId = mock(NodeId.class);
- Node mockNode = mock(Node.class);
- CallHomeMountSessionContext mockDevCtxt = mock(CallHomeMountSessionContext.class);
+ final NodeId mockNodeId = mock(NodeId.class);
+ final Node mockNode = mock(Node.class);
+ final CallHomeMountSessionContext mockDevCtxt = mock(CallHomeMountSessionContext.class);
doReturn(mockNodeId).when(mockDevCtxt).getId();
doReturn(mockNode).when(mockDevCtxt).getConfigNode();
doReturn(mockDevCtxt).when(mockSessMgr).createSession(any(CallHomeProtocolSessionContext.class),
any(CallHomeChannelActivator.class), any(CallHomeMountSessionContext.CloseCallback.class));
- CallHomeChannelActivator activator = mock(CallHomeChannelActivator.class);
+ final CallHomeChannelActivator activator = mock(CallHomeChannelActivator.class);
instance.createTopology();
// when
instance.onNetconfSubsystemOpened(mockProtoSess, activator);
<reference id="clientDispatcherDependency"
interface="org.opendaylight.netconf.client.NetconfClientDispatcher"
odl:type="netconf-client-dispatcher"/>
- <reference id="bindingAwareBroker"
- interface="org.opendaylight.controller.sal.binding.api.BindingAwareBroker"/>
<reference id="keepAliveExecutor"
interface="org.opendaylight.controller.config.threadpool.ScheduledThreadPool"
odl:type="global-netconf-ssh-scheduled-executor"/>
<reference id="processingExecutor"
interface="org.opendaylight.controller.config.threadpool.ThreadPool"
odl:type="global-netconf-processing-executor"/>
- <reference id="domBroker"
- interface="org.opendaylight.controller.sal.core.api.Broker"/>
<reference id="eventExecutor"
interface="io.netty.util.concurrent.EventExecutor"
odl:type="global-event-executor"/>
<reference id="dataBroker"
interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
+ <reference id="mountPointService"
+ interface="org.opendaylight.controller.md.sal.dom.api.DOMMountPointService"
+ odl:type="default"/>
<bean id="schemaRepository" class="org.opendaylight.netconf.topology.impl.SchemaRepositoryProviderImpl">
<argument value="shared-schema-repository-impl"/>
destroy-method="close">
<argument value="topology-netconf"/>
<argument ref="clientDispatcherDependency"/>
- <argument ref="bindingAwareBroker"/>
- <argument ref="domBroker"/>
<argument ref="eventExecutor"/>
<argument ref="keepAliveExecutor"/>
<argument ref="processingExecutor"/>
<argument ref="schemaRepository"/>
<argument ref="dataBroker"/>
+ <argument ref="mountPointService"/>
</bean>
<bean id="netconfConnectorFactory" class="org.opendaylight.netconf.topology.impl.NetconfConnectorFactoryImpl"/>
import com.google.common.base.Preconditions;
import java.util.List;
import java.util.stream.Collectors;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
private final RemoteDeviceId id;
private final Timeout actorResponseWaitTime;
+ private final NetconfDeviceSalProvider salProvider;
+ private final ActorRef masterActorRef;
+ private final ActorSystem actorSystem;
private SchemaContext remoteSchemaContext = null;
private NetconfSessionPreferences netconfSessionPreferences = null;
private DOMRpcService deviceRpc = null;
- private final NetconfDeviceSalProvider salProvider;
-
- private final ActorRef masterActorRef;
- private final ActorSystem actorSystem;
private DOMDataBroker deviceDataBroker = null;
MasterSalFacade(final RemoteDeviceId id,
- final Broker domBroker,
- final BindingAwareBroker bindingBroker,
final ActorSystem actorSystem,
final ActorRef masterActorRef,
- final Timeout actorResponseWaitTime) {
+ final Timeout actorResponseWaitTime,
+ final DOMMountPointService mountService,
+ final DataBroker dataBroker) {
this.id = id;
- this.salProvider = new NetconfDeviceSalProvider(id);
+ this.salProvider = new NetconfDeviceSalProvider(id, mountService, dataBroker);
this.actorSystem = actorSystem;
this.masterActorRef = masterActorRef;
this.actorResponseWaitTime = actorResponseWaitTime;
-
- registerToSal(domBroker, bindingBroker);
- }
-
- private void registerToSal(final Broker domRegistryDependency, final BindingAwareBroker bindingBroker) {
- // TODO: remove use of provider, there is possible directly create mount instance and
- // TODO: NetconfDeviceTopologyAdapter in constructor = less complexity
-
- domRegistryDependency.registerProvider(salProvider);
- bindingBroker.registerProvider(salProvider);
}
@Override
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.api.NetconfTopologySingletonService;
import org.opendaylight.netconf.topology.singleton.impl.actors.NetconfNodeActor;
private static final Logger LOG = LoggerFactory.getLogger(NetconfNodeManager.class);
+ private final Timeout actorResponseWaitTime;
+ private final DOMMountPointService mountPointService;
+ private final SchemaSourceRegistry schemaRegistry;
+ private final SchemaRepository schemaRepository;
+
private NetconfTopologySetup setup;
private ListenerRegistration<NetconfNodeManager> dataChangeListenerRegistration;
private RemoteDeviceId id;
- private final SchemaSourceRegistry schemaRegistry;
- private final SchemaRepository schemaRepository;
private ActorRef slaveActorRef;
- private final Timeout actorResponseWaitTime;
+
NetconfNodeManager(final NetconfTopologySetup setup,
- final RemoteDeviceId id, final Timeout actorResponseWaitTime) {
+ final RemoteDeviceId id, final Timeout actorResponseWaitTime,
+ final DOMMountPointService mountPointService) {
this.setup = setup;
this.id = id;
this.schemaRegistry = setup.getSchemaResourcesDTO().getSchemaRegistry();
this.schemaRepository = setup.getSchemaResourcesDTO().getSchemaRepository();
this.actorResponseWaitTime = actorResponseWaitTime;
+ this.mountPointService = mountPointService;
}
@Override
private void createActorRef() {
if (slaveActorRef == null) {
slaveActorRef = setup.getActorSystem().actorOf(NetconfNodeActor.props(setup, id, schemaRegistry,
- schemaRepository, actorResponseWaitTime), id.getName());
+ schemaRepository, actorResponseWaitTime, mountPointService), id.getName());
}
}
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import javax.annotation.Nonnull;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
private final ServiceGroupIdentifier serviceGroupIdent;
private final Timeout actorResponseWaitTime;
+ private final DOMMountPointService mountService;
+
private NetconfTopologySetup netconfTopologyDeviceSetup;
private RemoteDeviceId remoteDeviceId;
private RemoteDeviceConnector remoteDeviceConnector;
private NetconfNodeManager netconfNodeManager;
+ private ActorRef masterActorRef;
private boolean finalClose = false;
private boolean closed = false;
private boolean isMaster;
- private ActorRef masterActorRef;
-
NetconfTopologyContext(final NetconfTopologySetup netconfTopologyDeviceSetup,
final ServiceGroupIdentifier serviceGroupIdent,
- final Timeout actorResponseWaitTime) {
+ final Timeout actorResponseWaitTime, final DOMMountPointService mountService) {
this.netconfTopologyDeviceSetup = Preconditions.checkNotNull(netconfTopologyDeviceSetup);
this.serviceGroupIdent = serviceGroupIdent;
this.actorResponseWaitTime = actorResponseWaitTime;
+ this.mountService = mountService;
remoteDeviceId = NetconfTopologyUtils.createRemoteDeviceId(netconfTopologyDeviceSetup.getNode().getNodeId(),
netconfTopologyDeviceSetup.getNode().getAugmentation(NetconfNode.class));
remoteDeviceConnector = new RemoteDeviceConnectorImpl(netconfTopologyDeviceSetup, remoteDeviceId,
- actorResponseWaitTime);
+ actorResponseWaitTime, mountService);
netconfNodeManager = createNodeDeviceManager();
}
final String masterAddress = Cluster.get(netconfTopologyDeviceSetup.getActorSystem()).selfAddress().toString();
masterActorRef = netconfTopologyDeviceSetup.getActorSystem().actorOf(NetconfNodeActor.props(
netconfTopologyDeviceSetup, remoteDeviceId, DEFAULT_SCHEMA_REPOSITORY, DEFAULT_SCHEMA_REPOSITORY,
- actorResponseWaitTime),
+ actorResponseWaitTime, mountService),
NetconfTopologyUtils.createMasterActorName(remoteDeviceId.getName(), masterAddress));
remoteDeviceConnector.startRemoteDeviceConnection(masterActorRef);
private NetconfNodeManager createNodeDeviceManager() {
final NetconfNodeManager ndm =
- new NetconfNodeManager(netconfTopologyDeviceSetup, remoteDeviceId, actorResponseWaitTime);
+ new NetconfNodeManager(netconfTopologyDeviceSetup, remoteDeviceId, actorResponseWaitTime, mountService);
ndm.registerDataTreeChangeListener(netconfTopologyDeviceSetup.getTopologyId(),
netconfTopologyDeviceSetup.getNode().getKey());
if (!isMaster) {
netconfNodeManager.refreshDevice(netconfTopologyDeviceSetup, remoteDeviceId);
}
- remoteDeviceConnector = new RemoteDeviceConnectorImpl(netconfTopologyDeviceSetup, remoteDeviceId, actorResponseWaitTime);
+ remoteDeviceConnector = new RemoteDeviceConnectorImpl(netconfTopologyDeviceSetup, remoteDeviceId,
+ actorResponseWaitTime, mountService);
if (isMaster) {
final Future<Object> future = Patterns.ask(masterActorRef, new RefreshSetupMasterActorData(
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
private final Map<InstanceIdentifier<Node>, ClusterSingletonServiceRegistration>
clusterRegistrations = new HashMap<>();
- private ListenerRegistration<NetconfTopologyManager> dataChangeListenerRegistration;
-
private final DataBroker dataBroker;
private final RpcProviderRegistry rpcProviderRegistry;
private final ClusterSingletonServiceProvider clusterSingletonServiceProvider;
- private final BindingAwareBroker bindingAwareBroker;
private final ScheduledThreadPool keepaliveExecutor;
private final ThreadPool processingExecutor;
- private final Broker domBroker;
private final ActorSystem actorSystem;
private final EventExecutor eventExecutor;
private final NetconfClientDispatcher clientDispatcher;
private final String topologyId;
private final Duration writeTxIdleTimeout;
+ private final DOMMountPointService mountPointService;
+
+ private ListenerRegistration<NetconfTopologyManager> dataChangeListenerRegistration;
public NetconfTopologyManager(final DataBroker dataBroker, final RpcProviderRegistry rpcProviderRegistry,
final ClusterSingletonServiceProvider clusterSingletonServiceProvider,
- final BindingAwareBroker bindingAwareBroker,
final ScheduledThreadPool keepaliveExecutor, final ThreadPool processingExecutor,
- final Broker domBroker, final ActorSystemProvider actorSystemProvider,
- final EventExecutor eventExecutor, final NetconfClientDispatcher clientDispatcher,
- final String topologyId, final Config config) {
+ final ActorSystemProvider actorSystemProvider, final EventExecutor eventExecutor,
+ final NetconfClientDispatcher clientDispatcher, final String topologyId,
+ final Config config, final DOMMountPointService mountPointService) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
this.rpcProviderRegistry = Preconditions.checkNotNull(rpcProviderRegistry);
this.clusterSingletonServiceProvider = Preconditions.checkNotNull(clusterSingletonServiceProvider);
- this.bindingAwareBroker = Preconditions.checkNotNull(bindingAwareBroker);
this.keepaliveExecutor = Preconditions.checkNotNull(keepaliveExecutor);
this.processingExecutor = Preconditions.checkNotNull(processingExecutor);
- this.domBroker = Preconditions.checkNotNull(domBroker);
this.actorSystem = Preconditions.checkNotNull(actorSystemProvider).getActorSystem();
this.eventExecutor = Preconditions.checkNotNull(eventExecutor);
this.clientDispatcher = Preconditions.checkNotNull(clientDispatcher);
this.topologyId = Preconditions.checkNotNull(topologyId);
this.writeTxIdleTimeout = Duration.apply(config.getWriteTransactionIdleTimeout(), TimeUnit.SECONDS);
+ this.mountPointService = mountPointService;
}
// Blueprint init method
final NetconfTopologyContext newNetconfTopologyContext =
new NetconfTopologyContext(createSetup(instanceIdentifier, node), serviceGroupIdent,
- actorResponseWaitTime);
+ actorResponseWaitTime, mountPointService);
- final ClusterSingletonServiceRegistration clusterSingletonServiceRegistration =
+ final ClusterSingletonServiceRegistration clusterSingletonServiceRegistration =
clusterSingletonServiceProvider.registerClusterSingletonService(newNetconfTopologyContext);
clusterRegistrations.put(instanceIdentifier, clusterSingletonServiceRegistration);
LOG.debug("Registering datastore listener");
return dataBroker.registerDataTreeChangeListener(
- new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
- NetconfTopologyUtils.createTopologyListPath(topologyId).child(Node.class)), this);
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ NetconfTopologyUtils.createTopologyListPath(topologyId).child(Node.class)), this);
}
private void initTopology(final WriteTransaction wtx, final LogicalDatastoreType datastoreType, final String topologyId) {
.setInstanceIdentifier(instanceIdentifier)
.setRpcProviderRegistry(rpcProviderRegistry)
.setNode(node)
- .setBindingAwareBroker(bindingAwareBroker)
.setActorSystem(actorSystem)
.setEventExecutor(eventExecutor)
- .setDomBroker(domBroker)
.setKeepaliveExecutor(keepaliveExecutor)
.setProcessingExecutor(processingExecutor)
.setTopologyId(topologyId)
import java.util.Map;
import java.util.Optional;
import javax.annotation.Nullable;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
private static final Logger LOG = LoggerFactory.getLogger(RemoteDeviceConnectorImpl.class);
- private final Timeout actorResponseWaitTime;
-
// Initializes default constant instances for the case when the default schema repository
// directory cache/schema is used.
private final NetconfTopologySetup netconfTopologyDeviceSetup;
private final RemoteDeviceId remoteDeviceId;
+ private final DOMMountPointService mountService;
+ private final Timeout actorResponseWaitTime;
+
private NetconfConnectorDTO deviceCommunicatorDTO;
public RemoteDeviceConnectorImpl(final NetconfTopologySetup netconfTopologyDeviceSetup,
- final RemoteDeviceId remoteDeviceId, final Timeout actorResponseWaitTime) {
+ final RemoteDeviceId remoteDeviceId, final Timeout actorResponseWaitTime,
+ final DOMMountPointService mountService) {
this.netconfTopologyDeviceSetup = Preconditions.checkNotNull(netconfTopologyDeviceSetup);
this.remoteDeviceId = remoteDeviceId;
this.actorResponseWaitTime = actorResponseWaitTime;
+ this.mountService = mountService;
}
@Override
? NetconfTopologyUtils.DEFAULT_RECONNECT_ON_CHANGED_SCHEMA : node.isReconnectOnChangedSchema();
RemoteDeviceHandler<NetconfSessionPreferences> salFacade = new MasterSalFacade(remoteDeviceId,
- netconfTopologyDeviceSetup.getDomBroker(), netconfTopologyDeviceSetup.getBindingAwareBroker(),
- netconfTopologyDeviceSetup.getActorSystem(), deviceContextActorRef, actorResponseWaitTime);
+ netconfTopologyDeviceSetup.getActorSystem(), deviceContextActorRef, actorResponseWaitTime,
+ mountService, netconfTopologyDeviceSetup.getDataBroker());
if (keepaliveDelay > 0) {
LOG.info("{}: Adding keepalive facade.", remoteDeviceId);
salFacade = new KeepaliveSalFacade(remoteDeviceId, salFacade,
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.util.Timeout;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.sal.core.api.Broker;
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;
private final RemoteDeviceId id;
private final NetconfDeviceSalProvider salProvider;
-
private final ActorSystem actorSystem;
private final Timeout actorResponseWaitTime;
public SlaveSalFacade(final RemoteDeviceId id,
- final Broker domBroker,
final ActorSystem actorSystem,
- final Timeout actorResponseWaitTime) {
+ final Timeout actorResponseWaitTime,
+ final DOMMountPointService mountPointService) {
this.id = id;
- this.salProvider = new NetconfDeviceSalProvider(id);
+ this.salProvider = new NetconfDeviceSalProvider(id, mountPointService);
this.actorSystem = actorSystem;
this.actorResponseWaitTime = actorResponseWaitTime;
-
- registerToSal(domBroker);
- }
-
- private void registerToSal(final Broker domRegistryDependency) {
- domRegistryDependency.registerProvider(salProvider);
-
}
public void registerSlaveMountPoint(final SchemaContext remoteSchemaContext, final DOMRpcService deviceRpc,
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
private final SchemaSourceRegistry schemaRegistry;
private final SchemaRepository schemaRepository;
+ private final DOMMountPointService mountPointService;
private final Timeout actorResponseWaitTime;
private final Duration writeTxIdleTimeout;
public static Props props(final NetconfTopologySetup setup,
final RemoteDeviceId id, final SchemaSourceRegistry schemaRegistry,
- final SchemaRepository schemaRepository, final Timeout actorResponseWaitTime) {
+ final SchemaRepository schemaRepository, final Timeout actorResponseWaitTime,
+ final DOMMountPointService mountPointService) {
return Props.create(NetconfNodeActor.class, () ->
- new NetconfNodeActor(setup, id, schemaRegistry, schemaRepository, actorResponseWaitTime));
+ new NetconfNodeActor(setup, id, schemaRegistry, schemaRepository, actorResponseWaitTime,
+ mountPointService));
}
private NetconfNodeActor(final NetconfTopologySetup setup,
final RemoteDeviceId id, final SchemaSourceRegistry schemaRegistry,
- final SchemaRepository schemaRepository, final Timeout actorResponseWaitTime) {
+ final SchemaRepository schemaRepository, final Timeout actorResponseWaitTime,
+ final DOMMountPointService mountPointService) {
this.setup = setup;
this.id = id;
this.schemaRegistry = schemaRegistry;
this.schemaRepository = schemaRepository;
this.actorResponseWaitTime = actorResponseWaitTime;
this.writeTxIdleTimeout = setup.getIdleTimeout();
+ this.mountPointService = mountPointService;
}
@Override
slaveSalManager.close();
}
closeSchemaSourceRegistrations();
- slaveSalManager = new SlaveSalFacade(id, setup.getDomBroker(), setup.getActorSystem(), actorResponseWaitTime);
+ slaveSalManager = new SlaveSalFacade(id, setup.getActorSystem(), actorResponseWaitTime,
+ mountPointService);
final CheckedFuture<SchemaContext, SchemaResolutionException> remoteSchemaContext =
getSchemaContext(masterReference);
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDevice;
private final DataBroker dataBroker;
private final InstanceIdentifier<Node> instanceIdentifier;
private final Node node;
- private final BindingAwareBroker bindingAwareBroker;
private final ScheduledThreadPool keepaliveExecutor;
private final ThreadPool processingExecutor;
- private final Broker domBroker;
private final ActorSystem actorSystem;
private final EventExecutor eventExecutor;
private final NetconfClientDispatcher netconfClientDispatcher;
this.dataBroker = builder.getDataBroker();
this.instanceIdentifier = builder.getInstanceIdentifier();
this.node = builder.getNode();
- this.bindingAwareBroker = builder.getBindingAwareBroker();
this.keepaliveExecutor = builder.getKeepaliveExecutor();
this.processingExecutor = builder.getProcessingExecutor();
- this.domBroker = builder.getDomBroker();
this.actorSystem = builder.getActorSystem();
this.eventExecutor = builder.getEventExecutor();
this.netconfClientDispatcher = builder.getNetconfClientDispatcher();
return node;
}
- public BindingAwareBroker getBindingAwareBroker() {
- return bindingAwareBroker;
- }
-
public ThreadPool getProcessingExecutor() {
return processingExecutor;
}
return keepaliveExecutor;
}
- public Broker getDomBroker() {
- return domBroker;
- }
-
public ActorSystem getActorSystem() {
return actorSystem;
}
private DataBroker dataBroker;
private InstanceIdentifier<Node> instanceIdentifier;
private Node node;
- private BindingAwareBroker bindingAwareBroker;
private ScheduledThreadPool keepaliveExecutor;
private ThreadPool processingExecutor;
- private Broker domBroker;
private ActorSystem actorSystem;
private EventExecutor eventExecutor;
private String topologyId;
return new NetconfTopologySetup(this);
}
- private BindingAwareBroker getBindingAwareBroker() {
- return bindingAwareBroker;
- }
-
- public NetconfTopologySetupBuilder setBindingAwareBroker(final BindingAwareBroker bindingAwareBroker) {
- this.bindingAwareBroker = bindingAwareBroker;
- return this;
- }
-
private ScheduledThreadPool getKeepaliveExecutor() {
return keepaliveExecutor;
}
return this;
}
- private Broker getDomBroker() {
- return domBroker;
- }
-
- public NetconfTopologySetupBuilder setDomBroker(final Broker domBroker) {
- this.domBroker = domBroker;
- return this;
- }
-
private ActorSystem getActorSystem() {
return actorSystem;
}
interface="org.opendaylight.controller.sal.binding.api.RpcProviderRegistry"/>
<reference id="clusterSingletonService"
interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
- <reference id="bindingAwareBroker"
- interface="org.opendaylight.controller.sal.binding.api.BindingAwareBroker"/>
<reference id="keepAliveExecutor"
interface="org.opendaylight.controller.config.threadpool.ScheduledThreadPool"
odl:type="global-netconf-ssh-scheduled-executor"/>
<reference id="processingExecutor"
interface="org.opendaylight.controller.config.threadpool.ThreadPool"
odl:type="global-netconf-processing-executor"/>
- <reference id="domBroker"
- interface="org.opendaylight.controller.sal.core.api.Broker"/>
<reference id="actorSystemProvider"
interface="org.opendaylight.controller.cluster.ActorSystemProvider"/>
<reference id="eventExecutor"
<reference id="clientDispatcherDependency"
interface="org.opendaylight.netconf.client.NetconfClientDispatcher"
odl:type="netconf-client-dispatcher"/>
+ <reference id="mountPointService"
+ interface="org.opendaylight.controller.md.sal.dom.api.DOMMountPointService"
+ odl:type="default"/>
<odl:clustered-app-config
id="singletonConfig"
binding-class="org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.topology.singleton.config.rev170419.Config"
<argument ref="dataBroker"/>
<argument ref="rpcRegistry"/>
<argument ref="clusterSingletonService"/>
- <argument ref="bindingAwareBroker"/>
<argument ref="keepAliveExecutor"/>
<argument ref="processingExecutor"/>
- <argument ref="domBroker"/>
<argument ref="actorSystemProvider"/>
<argument ref="eventExecutor"/>
<argument ref="clientDispatcherDependency"/>
<argument value="topology-netconf"/>
<argument ref="singletonConfig"/>
+ <argument ref="mountPointService"/>
</bean>
<service ref="netconfTopologyManager"
interface="org.opendaylight.netconf.topology.singleton.api.NetconfTopologySingletonService"/>
import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
import org.opendaylight.controller.cluster.schema.provider.impl.YangTextSchemaSourceSerializationProxy;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.actors.NetconfNodeActor;
import org.opendaylight.netconf.topology.singleton.impl.utils.ClusteringRpcException;
@Mock
private DOMRpcService domRpcService;
+ @Mock
+ private DOMMountPointService mountPointService;
+ @Mock
+ private DataBroker dataBroker;
@Before
public void setup() throws UnknownHostException {
final NetconfTopologySetup setup = mock(NetconfTopologySetup.class);
final Props props = NetconfNodeActor.props(setup, remoteDeviceId, DEFAULT_SCHEMA_REPOSITORY,
- DEFAULT_SCHEMA_REPOSITORY, TIMEOUT);
+ DEFAULT_SCHEMA_REPOSITORY, TIMEOUT, mountPointService);
system = ActorSystem.create();
final Future<Object> initialDataToActor =
Patterns.ask(masterRef, new CreateInitialMasterActorData(domDataBroker, sourceIdentifiers,
- domRpcService), TIMEOUT);
+ domRpcService), TIMEOUT);
final Object success = Await.result(initialDataToActor, TIMEOUT.duration());
assertTrue(success instanceof MasterActorDataInitialized);
final Future<Object> initialDataToActor =
Patterns.ask(masterRef, new CreateInitialMasterActorData(domDataBroker, sourceIdentifiers,
- domRpcService), TIMEOUT);
+ domRpcService), TIMEOUT);
final Object successInit = Await.result(initialDataToActor, TIMEOUT.duration());
@Test
public void testReceiveRegisterMountpoint() throws Exception {
final NetconfTopologySetup setup = mock(NetconfTopologySetup.class);
- doReturn(mock(Broker.class)).when(setup).getDomBroker();
final RevisionSourceIdentifier yang1 = RevisionSourceIdentifier.create("yang1");
final RevisionSourceIdentifier yang2 = RevisionSourceIdentifier.create("yang2");
final SchemaSourceRegistry registry = mock(SchemaSourceRegistry.class);
Futures.makeChecked(schemaContextFuture, e -> new SchemaResolutionException("fail", e));
doReturn(checkedFuture).when(schemaContextFactory).createSchemaContext(any());
final ActorRef slaveRef =
- system.actorOf(NetconfNodeActor.props(setup, remoteDeviceId, registry, schemaRepository, TIMEOUT));
+ system.actorOf(NetconfNodeActor.props(setup, remoteDeviceId, registry, schemaRepository, TIMEOUT,
+ mountPointService));
final List<SourceIdentifier> sources = ImmutableList.of(yang1, yang2);
slaveRef.tell(new RegisterMountPoint(sources), masterRef);
final SchemaRepository schemaRepository = mock(SchemaRepository.class);
final SourceIdentifier sourceIdentifier = RevisionSourceIdentifier.create("testID", Optional.absent());
final Props props = NetconfNodeActor.props(mock(NetconfTopologySetup.class), remoteDeviceId,
- DEFAULT_SCHEMA_REPOSITORY, schemaRepository, TIMEOUT);
+ DEFAULT_SCHEMA_REPOSITORY, schemaRepository, TIMEOUT, mountPointService);
final ActorRef actorRefSchemaRepo = TestActorRef.create(system, props, "master_mocked_schema_repository");
final ActorContext actorContext = mock(ActorContext.class);
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
initMocks(this);
final RpcProviderRegistry rpcProviderRegistry = mock(RpcProviderRegistry.class);
- final BindingAwareBroker bindingAwareBroker = mock(BindingAwareBroker.class);
final ScheduledThreadPool keepaliveExecutor = mock(ScheduledThreadPool.class);
final ThreadPool processingExecutor = mock(ThreadPool.class);
- final Broker domBroker = mock(Broker.class);
final ActorSystemProvider actorSystemProvider = mock(ActorSystemProvider.class);
final EventExecutor eventExecutor = mock(EventExecutor.class);
final NetconfClientDispatcher clientDispatcher = mock(NetconfClientDispatcher.class);
+ final DOMMountPointService mountPointService = mock(DOMMountPointService.class);
final Config config = new ConfigBuilder().setWriteTransactionIdleTimeout(0).build();
netconfTopologyManager = new NetconfTopologyManager(dataBroker, rpcProviderRegistry,
- clusterSingletonServiceProvider, bindingAwareBroker, keepaliveExecutor, processingExecutor, domBroker,
- actorSystemProvider, eventExecutor, clientDispatcher, topologyId, config);
+ clusterSingletonServiceProvider, keepaliveExecutor, processingExecutor,
+ actorSystemProvider, eventExecutor, clientDispatcher, topologyId, config, mountPointService);
}
@Test
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.util.Timeout;
+import com.google.common.util.concurrent.Futures;
import io.netty.util.concurrent.EventExecutor;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import org.mockito.Mock;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
+import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
@Mock
private ClusterSingletonServiceProvider clusterSingletonServiceProvider;
- @Mock
- private BindingAwareBroker bindingAwareBroker;
-
@Mock
private ScheduledThreadPool keepaliveExecutor;
@Mock
private ThreadPool processingExecutor;
- @Mock
- private Broker domBroker;
-
@Mock
private ActorSystem actorSystem;
@Mock
private NetconfClientDispatcher clientDispatcher;
+ @Mock
+ private DOMMountPointService mountPointService;
+
+ @Mock
+ private BindingTransactionChain txChain;
+
+ @Mock
+ private WriteTransaction writeTx;
+
private NetconfTopologySetup.NetconfTopologySetupBuilder builder;
private RemoteDeviceId remoteDeviceId;
remoteDeviceId = new RemoteDeviceId(TOPOLOGY_ID,
new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 9999));
+ doReturn(txChain).when(dataBroker).createTransactionChain(any(TransactionChainListener.class));
+ doReturn(writeTx).when(txChain).newWriteOnlyTransaction();
+ doNothing().when(writeTx).merge(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
+ doReturn("Some object").when(writeTx).getIdentifier();
+ doReturn(Futures.immediateCheckedFuture(null)).when(writeTx).submit();
builder = new NetconfTopologySetup.NetconfTopologySetupBuilder();
builder.setDataBroker(dataBroker);
builder.setRpcProviderRegistry(rpcProviderRegistry);
builder.setClusterSingletonServiceProvider(clusterSingletonServiceProvider);
- builder.setBindingAwareBroker(bindingAwareBroker);
builder.setKeepaliveExecutor(keepaliveExecutor);
builder.setProcessingExecutor(processingExecutor);
- builder.setDomBroker(domBroker);
builder.setActorSystem(actorSystem);
builder.setEventExecutor(eventExecutor);
builder.setNetconfClientDispatcher(clientDispatcher);
builder.setNode(node);
- final NetconfDeviceCommunicator communicator = mock (NetconfDeviceCommunicator.class);
+ final NetconfDeviceCommunicator communicator = mock(NetconfDeviceCommunicator.class);
final RemoteDeviceHandler salFacade = mock(RemoteDeviceHandler.class);
final TestingRemoteDeviceConnectorImpl remoteDeviceConnection =
- new TestingRemoteDeviceConnectorImpl(builder.build(), remoteDeviceId, communicator, salFacade, TIMEOUT);
+ new TestingRemoteDeviceConnectorImpl(builder.build(), remoteDeviceId, communicator, salFacade, TIMEOUT,
+ mountPointService);
final ActorRef masterRef = mock(ActorRef.class);
final Node node = new NodeBuilder().setNodeId(NODE_ID).addAugmentation(NetconfNode.class, netconfNode).build();
builder.setSchemaResourceDTO(NetconfTopologyUtils.setupSchemaCacheDTO(node));
final RemoteDeviceConnectorImpl remoteDeviceConnection =
- new RemoteDeviceConnectorImpl(builder.build(), remoteDeviceId, TIMEOUT);
+ new RemoteDeviceConnectorImpl(builder.build(), remoteDeviceId, TIMEOUT, mountPointService);
final ActorRef masterRef = mock(ActorRef.class);
builder.setSchemaResourceDTO(NetconfTopologyUtils.setupSchemaCacheDTO(node));
final RemoteDeviceConnectorImpl remoteDeviceConnection =
- new RemoteDeviceConnectorImpl(builder.build(), remoteDeviceId, TIMEOUT);
+ new RemoteDeviceConnectorImpl(builder.build(), remoteDeviceId, TIMEOUT, mountPointService);
final ActorRef masterRef = mock(ActorRef.class);
.build();
final RemoteDeviceConnectorImpl remoteDeviceConnection =
- new RemoteDeviceConnectorImpl(builder.build(), remoteDeviceId, TIMEOUT);
+ new RemoteDeviceConnectorImpl(builder.build(), remoteDeviceId, TIMEOUT, mountPointService);
final NetconfReconnectingClientConfiguration defaultClientConfig =
remoteDeviceConnection.getClientConfig(listener, testingNode);
import akka.actor.ActorRef;
import akka.util.Timeout;
import com.google.common.util.concurrent.Futures;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
final RemoteDeviceId remoteDeviceId,
final NetconfDeviceCommunicator communicator,
final RemoteDeviceHandler salFacade,
- final Timeout actorResponseWaitTime) {
- super(netconfTopologyDeviceSetup, remoteDeviceId, actorResponseWaitTime);
+ final Timeout actorResponseWaitTime,
+ final DOMMountPointService mountPointService) {
+ super(netconfTopologyDeviceSetup, remoteDeviceId, actorResponseWaitTime, mountPointService);
this.communicator = communicator;
this.salFacade = salFacade;
}
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.ProxyDOMDataBroker;
private ActorRef masterRef;
private ProxyDOMDataBroker slaveDataBroker;
private List<SourceIdentifier> sourceIdentifiers;
+ private YangInstanceIdentifier instanceIdentifier;
+ private LogicalDatastoreType storeType;
@Mock
private DOMDataBroker deviceDataBroker;
@Mock
private DOMDataReadOnlyTransaction readTx;
@Mock
private DOMRpcService domRpcService;
- private YangInstanceIdentifier instanceIdentifier;
- private LogicalDatastoreType storeType;
+ @Mock
+ private DOMMountPointService mountPointService;
@Before
public void setup() throws Exception {
final NetconfTopologySetup setup = mock(NetconfTopologySetup.class);
final Props props = NetconfNodeActor.props(setup, remoteDeviceId, DEFAULT_SCHEMA_REPOSITORY,
- DEFAULT_SCHEMA_REPOSITORY, TIMEOUT);
+ DEFAULT_SCHEMA_REPOSITORY, TIMEOUT, mountPointService);
masterRef = TestActorRef.create(system, props, "master_read");
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.ProxyDOMDataBroker;
private DOMDataReadWriteTransaction readWriteTx;
@Mock
private DOMRpcService domRpcService;
+ @Mock
+ private DOMMountPointService mountPointService;
private ActorRef masterRef;
private ProxyDOMDataBroker slaveDataBroker;
private List<SourceIdentifier> sourceIdentifiers;
final NetconfTopologySetup setup = mock(NetconfTopologySetup.class);
doReturn(Duration.apply(0, TimeUnit.SECONDS)).when(setup).getIdleTimeout();
final Props props = NetconfNodeActor.props(setup, remoteDeviceId, DEFAULT_SCHEMA_REPOSITORY,
- DEFAULT_SCHEMA_REPOSITORY, TIMEOUT);
+ DEFAULT_SCHEMA_REPOSITORY, TIMEOUT, mountPointService);
masterRef = TestActorRef.create(system, props, "master_read");
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.mockito.Mock;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.impl.ProxyDOMDataBroker;
@Rule
public final ExpectedException exception = ExpectedException.none();
+ private ActorRef masterRef;
+ private ProxyDOMDataBroker slaveDataBroker;
+ private List<SourceIdentifier> sourceIdentifiers;
@Mock
private DOMDataBroker deviceDataBroker;
@Mock
private DOMDataWriteTransaction writeTx;
@Mock
private DOMRpcService domRpcService;
- private ActorRef masterRef;
- private ProxyDOMDataBroker slaveDataBroker;
- private List<SourceIdentifier> sourceIdentifiers;
+ @Mock
+ private DOMMountPointService mountPointService;
+
private NormalizedNode<?, ?> testNode;
private YangInstanceIdentifier instanceIdentifier;
private LogicalDatastoreType storeType;
final NetconfTopologySetup setup = mock(NetconfTopologySetup.class);
doReturn(Duration.apply(0, TimeUnit.SECONDS)).when(setup).getIdleTimeout();
final Props props = NetconfNodeActor.props(setup, remoteDeviceId, DEFAULT_SCHEMA_REPOSITORY,
- DEFAULT_SCHEMA_REPOSITORY, TIMEOUT);
+ DEFAULT_SCHEMA_REPOSITORY, TIMEOUT, mountPointService);
masterRef = TestActorRef.create(system, props, "master_read");
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
protected final String topologyId;
private final NetconfClientDispatcher clientDispatcher;
- protected final BindingAwareBroker bindingAwareBroker;
- protected final Broker domBroker;
private final EventExecutor eventExecutor;
protected final ScheduledThreadPool keepaliveExecutor;
protected final ThreadPool processingExecutor;
protected final SharedSchemaRepository sharedSchemaRepository;
protected final DataBroker dataBroker;
+ protected final DOMMountPointService mountPointService;
protected SchemaSourceRegistry schemaRegistry = DEFAULT_SCHEMA_REPOSITORY;
protected SchemaRepository schemaRepository = DEFAULT_SCHEMA_REPOSITORY;
protected final HashMap<NodeId, NetconfConnectorDTO> activeConnectors = new HashMap<>();
protected AbstractNetconfTopology(final String topologyId, final NetconfClientDispatcher clientDispatcher,
- final BindingAwareBroker bindingAwareBroker, final Broker domBroker,
final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
final ThreadPool processingExecutor, final SchemaRepositoryProvider schemaRepositoryProvider,
- final DataBroker dataBroker) {
+ final DataBroker dataBroker, final DOMMountPointService mountPointService) {
this.topologyId = topologyId;
this.clientDispatcher = clientDispatcher;
- this.bindingAwareBroker = bindingAwareBroker;
- this.domBroker = domBroker;
this.eventExecutor = eventExecutor;
this.keepaliveExecutor = keepaliveExecutor;
this.processingExecutor = processingExecutor;
this.sharedSchemaRepository = schemaRepositoryProvider.getSharedSchemaRepository();
this.dataBroker = dataBroker;
+ this.mountPointService = mountPointService;
}
public void setSchemaRegistry(final SchemaSourceRegistry schemaRegistry) {
final RemoteDeviceId remoteDeviceId = new RemoteDeviceId(nodeId.getValue(), address);
RemoteDeviceHandler<NetconfSessionPreferences> salFacade =
- createSalFacade(remoteDeviceId, domBroker, bindingAwareBroker);
+ createSalFacade(remoteDeviceId);
if (keepaliveDelay > 0) {
LOG.warn("Adding keepalive facade, for device {}", nodeId);
.build();
}
- protected abstract RemoteDeviceHandler<NetconfSessionPreferences> createSalFacade(final RemoteDeviceId id, final Broker domBroker, final BindingAwareBroker bindingBroker);
+ protected abstract RemoteDeviceHandler<NetconfSessionPreferences> createSalFacade(final RemoteDeviceId id);
private InetSocketAddress getSocketAddress(final Host host, final int port) {
if(host.getDomainName() != null) {
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
private ListenerRegistration<NetconfTopologyImpl> datastoreListenerRegistration = null;
public NetconfTopologyImpl(final String topologyId, final NetconfClientDispatcher clientDispatcher,
- final BindingAwareBroker bindingAwareBroker, final Broker domBroker,
final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
final ThreadPool processingExecutor, final SchemaRepositoryProvider schemaRepositoryProvider,
- final DataBroker dataBroker) {
- super(topologyId, clientDispatcher,
- bindingAwareBroker, domBroker, eventExecutor,
- keepaliveExecutor, processingExecutor, schemaRepositoryProvider, dataBroker);
+ final DataBroker dataBroker, final DOMMountPointService mountPointService) {
+ super(topologyId, clientDispatcher, eventExecutor, keepaliveExecutor, processingExecutor,
+ schemaRepositoryProvider, dataBroker, mountPointService);
}
@Override
public void close() throws Exception {
// close all existing connectors, delete whole topology in datastore?
- for (NetconfConnectorDTO connectorDTO : activeConnectors.values()) {
+ for (final NetconfConnectorDTO connectorDTO : activeConnectors.values()) {
connectorDTO.close();
}
activeConnectors.clear();
}
@Override
- protected RemoteDeviceHandler<NetconfSessionPreferences> createSalFacade(RemoteDeviceId id, Broker domBroker, BindingAwareBroker bindingBroker) {
- return new NetconfDeviceSalFacade(id, domBroker, bindingAwareBroker);
+ protected RemoteDeviceHandler<NetconfSessionPreferences> createSalFacade(final RemoteDeviceId id) {
+ return new NetconfDeviceSalFacade(id, mountPointService, dataBroker);
}
/**
initTopology(wtx, LogicalDatastoreType.OPERATIONAL);
Futures.addCallback(wtx.submit(), new FutureCallback<Void>() {
@Override
- public void onSuccess(Void result) {
+ public void onSuccess(final Void result) {
LOG.debug("topology initialization successful");
}
@Override
- public void onFailure(Throwable t) {
+ public void onFailure(final Throwable t) {
LOG.error("Unable to initialize netconf-topology, {}", t);
}
});
}
@Override
- public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<Node>> collection) {
- for (DataTreeModification<Node> change : collection) {
+ public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<Node>> collection) {
+ for (final DataTreeModification<Node> change : collection) {
final DataObjectModification<Node> rootNode = change.getRootNode();
switch (rootNode.getModificationType()) {
case SUBTREE_MODIFIED:
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.conf.NetconfReconnectingClientConfiguration;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
private static final NodeId NODE_ID = new NodeId("testing-node");
private static final String TOPOLOGY_ID = "testing-topology";
- @Mock
- private Broker mockedDataBroker;
-
@Mock
private NetconfClientDispatcher mockedClientDispatcher;
- @Mock
- private BindingAwareBroker mockedBindingAwareBroker;
-
@Mock
private EventExecutor mockedEventExecutor;
@Mock
private DataBroker dataBroker;
+ @Mock
+ private DOMMountPointService mountPointService;
+
private TestingNetconfTopologyImpl topology;
private TestingNetconfTopologyImpl spyTopology;
when(mockedSchemaRepositoryProvider.getSharedSchemaRepository()).thenReturn(new SharedSchemaRepository("testingSharedSchemaRepo"));
when(mockedProcessingExecutor.getExecutor()).thenReturn(MoreExecutors.newDirectExecutorService());
- Future future = new SucceededFuture(ImmediateEventExecutor.INSTANCE, new NetconfDeviceCapabilities());
+ final Future future = new SucceededFuture(ImmediateEventExecutor.INSTANCE, new NetconfDeviceCapabilities());
when(mockedClientDispatcher.createReconnectingClient(any(NetconfReconnectingClientConfiguration.class))).thenReturn(future);
- topology = new TestingNetconfTopologyImpl(TOPOLOGY_ID, mockedClientDispatcher, mockedBindingAwareBroker,
- mockedDataBroker, mockedEventExecutor, mockedKeepaliveExecutor, mockedProcessingExecutor, mockedSchemaRepositoryProvider,
- dataBroker);
+ topology = new TestingNetconfTopologyImpl(TOPOLOGY_ID, mockedClientDispatcher,
+ mockedEventExecutor, mockedKeepaliveExecutor, mockedProcessingExecutor, mockedSchemaRepositoryProvider,
+ dataBroker, mountPointService);
spyTopology = spy(topology);
}
@Test
public void testInit() {
- WriteTransaction wtx = mock(WriteTransaction.class);
+ final WriteTransaction wtx = mock(WriteTransaction.class);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(wtx);
doNothing().when(wtx).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(DataObject.class));
when(wtx.submit()).thenReturn(Futures.<Void, TransactionCommitFailedException>immediateCheckedFuture(null));
@Test
public void testOnDataTreeChange() {
- DataObjectModification<Node> newNode = mock(DataObjectModification.class);
+ final DataObjectModification<Node> newNode = mock(DataObjectModification.class);
when(newNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);
InstanceIdentifier.PathArgument pa = null;
- for (InstanceIdentifier.PathArgument p : TopologyUtil.createTopologyListPath(TOPOLOGY_ID).child(Node.class, new NodeKey(NODE_ID)).getPathArguments()) {
+ for (final InstanceIdentifier.PathArgument p : TopologyUtil.createTopologyListPath(TOPOLOGY_ID).child(Node.class, new NodeKey(NODE_ID)).getPathArguments()) {
pa = p;
}
when(newNode.getIdentifier()).thenReturn(pa);
- NetconfNode testingNode = new NetconfNodeBuilder()
+ final NetconfNode testingNode = new NetconfNodeBuilder()
.setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
.setPort(new PortNumber(9999))
.setReconnectOnChangedSchema(true)
.setCredentials(new LoginPasswordBuilder().setUsername("testuser").setPassword("testpassword").build())
.build();
- NodeBuilder nn = new NodeBuilder().addAugmentation(NetconfNode.class, testingNode);
+ final NodeBuilder nn = new NodeBuilder().addAugmentation(NetconfNode.class, testingNode);
when(newNode.getDataAfter()).thenReturn(nn.build());
-
- Collection<DataTreeModification<Node>> changes = Sets.newHashSet();
- DataTreeModification<Node> ch = mock(DataTreeModification.class);
+ final Collection<DataTreeModification<Node>> changes = Sets.newHashSet();
+ final DataTreeModification<Node> ch = mock(DataTreeModification.class);
when(ch.getRootNode()).thenReturn(newNode);
changes.add(ch);
spyTopology.onDataTreeChanged(changes);
public static class TestingNetconfTopologyImpl extends NetconfTopologyImpl {
- public TestingNetconfTopologyImpl(String topologyId, NetconfClientDispatcher clientDispatcher,
- BindingAwareBroker bindingAwareBroker, Broker domBroker,
- EventExecutor eventExecutor, ScheduledThreadPool keepaliveExecutor,
- ThreadPool processingExecutor, SchemaRepositoryProvider schemaRepositoryProvider,
- DataBroker dataBroker) {
- super(topologyId, clientDispatcher, bindingAwareBroker, domBroker, eventExecutor, keepaliveExecutor,
- processingExecutor, schemaRepositoryProvider, dataBroker);
+ public TestingNetconfTopologyImpl(final String topologyId, final NetconfClientDispatcher clientDispatcher,
+ final EventExecutor eventExecutor, final ScheduledThreadPool keepaliveExecutor,
+ final ThreadPool processingExecutor, final SchemaRepositoryProvider schemaRepositoryProvider,
+ final DataBroker dataBroker, final DOMMountPointService mountPointService) {
+ super(topologyId, clientDispatcher, eventExecutor, keepaliveExecutor,
+ processingExecutor, schemaRepositoryProvider, dataBroker, mountPointService);
}
@Override
- public ListenableFuture<NetconfDeviceCapabilities> connectNode(NodeId nodeId, Node configNode) {
+ public ListenableFuture<NetconfDeviceCapabilities> connectNode(final NodeId nodeId, final Node configNode) {
return Futures.immediateFuture(new NetconfDeviceCapabilities());
}
@Override
- public ListenableFuture<Void> disconnectNode(NodeId nodeId) {
+ public ListenableFuture<Void> disconnectNode(final NodeId nodeId) {
return Futures.immediateFuture(null);
}
}
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Lists;
import java.util.List;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
private final RemoteDeviceId id;
private final NetconfDeviceSalProvider salProvider;
-
private final List<AutoCloseable> salRegistrations = Lists.newArrayList();
- public NetconfDeviceSalFacade(final RemoteDeviceId id, final Broker domBroker, final BindingAwareBroker bindingBroker) {
+ public NetconfDeviceSalFacade(final RemoteDeviceId id, final DOMMountPointService mountPointService,
+ final DataBroker dataBroker) {
this.id = id;
- this.salProvider = new NetconfDeviceSalProvider(id);
- registerToSal(domBroker, bindingBroker);
+ this.salProvider = new NetconfDeviceSalProvider(id, mountPointService, dataBroker);
}
@VisibleForTesting
- NetconfDeviceSalFacade(final RemoteDeviceId id, NetconfDeviceSalProvider salProvider,
- final Broker domBroker, final BindingAwareBroker bindingBroker) {
+ NetconfDeviceSalFacade(final RemoteDeviceId id, final NetconfDeviceSalProvider salProvider) {
this.id = id;
this.salProvider = salProvider;
- registerToSal(domBroker, bindingBroker);
- }
-
- public void registerToSal(final Broker domRegistryDependency, final BindingAwareBroker bindingBroker) {
- domRegistryDependency.registerProvider(salProvider);
- bindingBroker.registerProvider(salProvider);
}
@Override
package org.opendaylight.netconf.sal.connect.netconf.sal;
import com.google.common.base.Preconditions;
-import java.util.Collection;
-import java.util.Collections;
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
-import org.opendaylight.controller.sal.core.api.Broker;
-import org.opendaylight.controller.sal.core.api.Provider;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NetconfDeviceSalProvider implements AutoCloseable, Provider, BindingAwareProvider {
+public class NetconfDeviceSalProvider implements AutoCloseable {
private static final Logger logger = LoggerFactory.getLogger(NetconfDeviceSalProvider.class);
private final RemoteDeviceId id;
- private MountInstance mountInstance;
+ private final MountInstance mountInstance;
+ private final DataBroker dataBroker;
private volatile NetconfDeviceTopologyAdapter topologyDatastoreAdapter;
- private DataBroker dataBroker;
private BindingTransactionChain txChain;
private final TransactionChainListener transactionChainListener = new TransactionChainListener() {
@Override
- public void onTransactionChainFailed(TransactionChain<?, ?> chain, AsyncTransaction<?, ?> transaction, Throwable cause) {
+ public void onTransactionChainFailed(final TransactionChain<?, ?> chain, final AsyncTransaction<?, ?> transaction, final Throwable cause) {
logger.error("{}: TransactionChain({}) {} FAILED!", id, chain, transaction.getIdentifier(), cause);
chain.close();
resetTransactionChainForAdapaters();
}
@Override
- public void onTransactionChainSuccessful(TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
logger.trace("{}: TransactionChain({}) {} SUCCESSFUL", id, chain);
}
};
- public NetconfDeviceSalProvider(final RemoteDeviceId deviceId) {
+ public NetconfDeviceSalProvider(final RemoteDeviceId deviceId, final DOMMountPointService mountService,
+ final DataBroker dataBroker) {
this.id = deviceId;
+ mountInstance = new MountInstance(mountService, id);
+ this.dataBroker = dataBroker;
+ txChain = Preconditions.checkNotNull(dataBroker).createTransactionChain(transactionChainListener);
+
+ topologyDatastoreAdapter = new NetconfDeviceTopologyAdapter(id, txChain);
+ }
+
+ public NetconfDeviceSalProvider(final RemoteDeviceId deviceId, final DOMMountPointService mountService) {
+ this.id = deviceId;
+ mountInstance = new MountInstance(mountService, id);
+ this.dataBroker = null;
}
public MountInstance getMountInstance() {
return topologyDatastoreAdapter;
}
- @Override
- public void onSessionInitiated(final Broker.ProviderSession session) {
- logger.debug("{}: (BI)Session with sal established {}", id, session);
-
- final DOMMountPointService mountService = session.getService(DOMMountPointService.class);
- if (mountService != null) {
- mountInstance = new MountInstance(mountService, id);
- }
- }
-
- @Override
- public Collection<Provider.ProviderFunctionality> getProviderFunctionality() {
- return Collections.emptySet();
- }
-
- @Override
- public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
- logger.debug("{}: Session with sal established {}", id, session);
-
- this.dataBroker = session.getSALService(DataBroker.class);
- txChain = Preconditions.checkNotNull(dataBroker).createTransactionChain(transactionChainListener);
-
- topologyDatastoreAdapter = new NetconfDeviceTopologyAdapter(id, txChain);
- }
-
private void resetTransactionChainForAdapaters() {
txChain = Preconditions.checkNotNull(dataBroker).createTransactionChain(transactionChainListener);
public static final class MountInstance implements AutoCloseable {
- private DOMMountPointService mountService;
+ private final DOMMountPointService mountService;
private final RemoteDeviceId id;
private NetconfDeviceNotificationService notificationService;
}
public synchronized void onTopologyDeviceConnected(final SchemaContext initialCtx,
- final DOMDataBroker broker, final DOMRpcService rpc,
- final NetconfDeviceNotificationService notificationService) {
-
+ final DOMDataBroker broker, final DOMRpcService rpc,
+ final NetconfDeviceNotificationService notificationService) {
Preconditions.checkNotNull(mountService, "Closed");
Preconditions.checkState(topologyRegistration == null, "Already initialized");
@Override
public synchronized void close() throws Exception {
onTopologyDeviceDisconnected();
- mountService = null;
}
public synchronized void publish(final DOMNotification domNotification) {
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
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.util.NetconfMessageTransformUtil;
final InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8000);
final RemoteDeviceId remoteDeviceId = new RemoteDeviceId("test", address);
- final Broker domRegistry = mock(Broker.class);
- final BindingAwareBroker bindingRegistry = mock(BindingAwareBroker.class);
- deviceFacade = new NetconfDeviceSalFacade(remoteDeviceId, salProvider, domRegistry, bindingRegistry);
+ deviceFacade = new NetconfDeviceSalFacade(remoteDeviceId, salProvider);
netconfDeviceTopologyAdapter = PowerMockito.mock(NetconfDeviceTopologyAdapter.class);
mountInstance = PowerMockito.mock(NetconfDeviceSalProvider.MountInstance.class);
package org.opendaylight.netconf.sal.connect.netconf.sal;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.google.common.util.concurrent.Futures;
import java.net.InetSocketAddress;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
private DataBroker dataBroker;
@Mock
private BindingTransactionChain chain;
+ @Mock
+ private DOMMountPointService mountPointService;
+ @Mock
+ private WriteTransaction writeTx;
private NetconfDeviceSalProvider provider;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
- provider = new NetconfDeviceSalProvider(new RemoteDeviceId("device1", InetSocketAddress.createUnresolved("localhost", 17830)));
+ doReturn(chain).when(dataBroker).createTransactionChain(any(TransactionChainListener.class));
+ doReturn(writeTx).when(chain).newWriteOnlyTransaction();
+ doNothing().when(writeTx).merge(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
+ doReturn("Some object").when(writeTx).getIdentifier();
+ doReturn(Futures.immediateCheckedFuture(null)).when(writeTx).submit();
+ provider = new NetconfDeviceSalProvider(new RemoteDeviceId("device1",
+ InetSocketAddress.createUnresolved("localhost", 17830)), mountPointService, dataBroker);
when(session.getService(DOMMountPointService.class)).thenReturn(mountpointService);
when(context.getSALService(DataBroker.class)).thenReturn(dataBroker);
- when(dataBroker.createTransactionChain(any())).thenReturn(chain);
when(chain.newWriteOnlyTransaction()).thenReturn(tx);
when(tx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
when(tx.getIdentifier()).thenReturn(tx);
}
- @Test
- public void onSessionInitiated() throws Exception {
- provider.onSessionInitiated(session);
- provider.onSessionInitiated(context);
- Assert.assertNotNull(provider.getMountInstance());
- Assert.assertNotNull(provider.getTopologyDatastoreAdapter());
- }
-
- @Test
- public void getProviderFunctionality() throws Exception {
- Assert.assertTrue(provider.getProviderFunctionality().isEmpty());
- }
-
@Test
public void replaceChainIfFailed() throws Exception {
- provider.onSessionInitiated(session);
- provider.onSessionInitiated(context);
- Assert.assertNotNull(provider.getMountInstance());
final ArgumentCaptor<TransactionChainListener> captor = ArgumentCaptor.forClass(TransactionChainListener.class);
verify(dataBroker).createTransactionChain(captor.capture());
try {
@Test
public void close() throws Exception {
- provider.onSessionInitiated(session);
- provider.onSessionInitiated(context);
provider.close();
verify(chain).close();
}
@Test
public void closeWithoutNPE() throws Exception {
- provider.onSessionInitiated(session);
- provider.onSessionInitiated(context);
provider.close();
provider.close();
verify(chain, times(2)).close();