*/
package org.opendaylight.transportpce.inventory;
+import java.util.ArrayList;
+import java.util.List;
import javax.sql.DataSource;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.transportpce.inventory.listener.OverlayNetworkChangeListener;
import org.opendaylight.transportpce.inventory.listener.UnderlayNetworkChangeListener;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.concepts.Registration;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ListenerProvider {
private static final Logger LOG = LoggerFactory.getLogger(ListenerProvider.class);
+ private List<Registration> listeners = new ArrayList<>();
/**
* Constructor invoked by blueprint injects all dependencies.
LOG.debug("Registering listeners...");
OverlayNetworkChangeListener overlayNetworkListener = new OverlayNetworkChangeListener();
- dataBroker.registerDataTreeChangeListener(
+ listeners.add(dataBroker.registerDataTreeChangeListener(
DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, InstanceIdentifiers.OVERLAY_NETWORK_II),
- overlayNetworkListener);
+ overlayNetworkListener));
LOG.info("Overlay network change listener was successfully registered");
UnderlayNetworkChangeListener underlayNetworkListener = new UnderlayNetworkChangeListener();
- dataBroker.registerDataTreeChangeListener(
+ listeners.add(dataBroker.registerDataTreeChangeListener(
DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, InstanceIdentifiers.UNDERLAY_NETWORK_II),
- underlayNetworkListener);
+ underlayNetworkListener));
LOG.info("Underlay network change listener was successfully registered");
ClliNetworkChangeListener clliNetworkChangeListener = new ClliNetworkChangeListener();
- dataBroker.registerDataTreeChangeListener(
+ listeners.add(dataBroker.registerDataTreeChangeListener(
DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, InstanceIdentifiers.CLLI_NETWORK_II),
- clliNetworkChangeListener);
+ clliNetworkChangeListener));
LOG.info("CLLI network change listener was successfully registered");
INode121 inode121 = new INode121(dataSource, deviceTransactionManager);
INode inode = new INode(dataSource, inode121);
DeviceInventory deviceInventory = new DeviceInventory(dataSource, inode);
DeviceListener deviceListener = new DeviceListener(deviceInventory);
- dataBroker.registerDataTreeChangeListener(
+ listeners.add(dataBroker.registerDataTreeChangeListener(
DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifiers.NETCONF_TOPOLOGY_II.child(Node.class)), deviceListener);
+ InstanceIdentifiers.NETCONF_TOPOLOGY_II.child(Node.class)), deviceListener));
LOG.info("Device change listener was successfully registered");
DeviceConfigListener deviceConfigListener = new DeviceConfigListener(deviceInventory);
- dataBroker.registerDataTreeChangeListener(
+ listeners.add(dataBroker.registerDataTreeChangeListener(
DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifiers.NETCONF_TOPOLOGY_II.child(Node.class)), deviceConfigListener);
+ InstanceIdentifiers.NETCONF_TOPOLOGY_II.child(Node.class)), deviceConfigListener));
LOG.info("Device config change listener was successfully registered");
}
+ @Deactivate
+ public void close() {
+ listeners.forEach(lis -> lis.close());
+ listeners.clear();
+ }
}
*/
package org.opendaylight.transportpce.networkmodel;
+import java.util.ArrayList;
+import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
private final RpcProviderService rpcProviderService;
private final TransportpceNetworkutilsService networkutilsService;
private final NetConfTopologyListener topologyListener;
- private ListenerRegistration<NetConfTopologyListener> dataTreeChangeListenerRegistration;
- private ListenerRegistration<PortMappingListener> mappingListenerRegistration;
+ private List<Registration> listeners;
private @NonNull Registration networkutilsServiceRpcRegistration;
private TpceNetwork tpceNetwork;
private ListenerRegistration<TransportpceServicehandlerListener> serviceHandlerListenerRegistration;
this.rpcProviderService = rpcProviderService;
this.notificationService = notificationService;
this.frequenciesService = frequenciesService;
+ this.listeners = new ArrayList<>();
this.networkutilsService = new NetworkUtilsImpl(dataBroker);
this.topologyListener = new NetConfTopologyListener(networkModelService, dataBroker, deviceTransactionManager,
portMapping);
tpceNetwork.createLayer(NetworkUtils.UNDERLAY_NETWORK_ID);
tpceNetwork.createLayer(NetworkUtils.OVERLAY_NETWORK_ID);
tpceNetwork.createLayer(NetworkUtils.OTN_NETWORK_ID);
- dataTreeChangeListenerRegistration = dataBroker.registerDataTreeChangeListener(
+ listeners.add(dataBroker.registerDataTreeChangeListener(
DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifiers.NETCONF_TOPOLOGY_II.child(Node.class)), topologyListener);
- mappingListenerRegistration = dataBroker.registerDataTreeChangeListener(
- DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, MAPPING_II), portMappingListener);
+ InstanceIdentifiers.NETCONF_TOPOLOGY_II.child(Node.class)), topologyListener));
+ listeners.add(dataBroker.registerDataTreeChangeListener(
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, MAPPING_II), portMappingListener));
networkutilsServiceRpcRegistration = rpcProviderService
.registerRpcImplementation(TransportpceNetworkutilsService.class, networkutilsService);
TransportpceServicehandlerListener serviceHandlerListner = new ServiceHandlerListener(frequenciesService);
@Deactivate
public void close() {
LOG.info("NetworkModelProvider Closed");
- if (dataTreeChangeListenerRegistration != null) {
- dataTreeChangeListenerRegistration.close();
- }
- if (mappingListenerRegistration != null) {
- mappingListenerRegistration.close();
- }
+ listeners.forEach(lis -> lis.close());
+ listeners.clear();
if (networkutilsServiceRpcRegistration != null) {
networkutilsServiceRpcRegistration.close();
}
import org.mockito.invocation.InvocationOnMock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.stubbing.Answer;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.transportpce.networkmodel.service.FrequenciesService;
import org.opendaylight.transportpce.networkmodel.service.NetworkModelService;
-import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev220630.TransportpceNetworkutilsService;
@ExtendWith(MockitoExtension.class)
-public class NetworkModelProviderTest extends AbstractTest {
+public class NetworkModelProviderTest {
@Mock
NetworkTransactionService networkTransactionService;
@Mock
+ DataBroker dataBroker;
+ @Mock
RpcProviderService rpcProviderService;
@Mock
NetworkModelService networkModelService;
};
when(networkTransactionService.commit()).then(answer);
- new NetworkModelProvider(networkTransactionService, getDataBroker(),
- rpcProviderService, networkModelService, deviceTransactionManager, portMapping, notificationService,
- frequenciesService);
+ new NetworkModelProvider(networkTransactionService, dataBroker, rpcProviderService, networkModelService,
+ deviceTransactionManager, portMapping, notificationService, frequenciesService);
verify(rpcProviderService, times(1))
.registerRpcImplementation(any(), any(TransportpceNetworkutilsService.class));
+ verify(dataBroker, times(2)).registerDataTreeChangeListener(any(), any());
}
}
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.service.list.Services;
@ExtendWith(MockitoExtension.class)
-public class ServicehandlerProviderTest extends AbstractTest {
+public class ServicehandlerProviderTest extends AbstractTest {
+ @Mock
+ DataBroker dataBroker;
@Mock
RpcProviderService rpcProviderRegistry;
@Mock
@Test
void testInitRegisterServiceHandlerToRpcRegistry() {
- ServicehandlerProvider provider = new ServicehandlerProvider(getDataBroker(), rpcProviderRegistry,
- getNotificationService() , serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl,
- networkModelListenerImpl, notificationPublishService, servicehandler, serviceListener);
+ new ServicehandlerProvider(dataBroker, rpcProviderRegistry, getNotificationService() ,
+ serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl, networkModelListenerImpl,
+ notificationPublishService, servicehandler, serviceListener);
verify(rpcProviderRegistry, times(1)).registerRpcImplementation(any(), any(OrgOpenroadmServiceService.class));
+ verify(dataBroker, times(1)).registerDataTreeChangeListener(any(), any());
}
}
\ No newline at end of file
*/
package org.opendaylight.transportpce.tapi.impl;
+import java.util.ArrayList;
import java.util.HashMap;
+import java.util.List;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
private TapiNotificationListener tapiNetworkModelListenerImpl;
private ObjectRegistration<TapiConnectivityService> rpcRegistration;
private ObjectRegistration<TransportpceTapinetworkutilsService> tapiNetworkutilsServiceRpcRegistration;
- private ListenerRegistration<TapiNetconfTopologyListener> dataTreeChangeListenerRegistration;
- private ListenerRegistration<TapiOrLinkListener> dataTreeChangeListenerRegistration1;
- private ListenerRegistration<TapiPortMappingListener> mappingListenerListenerRegistration;
+ private List<Registration> listeners;
private ListenerRegistration<TransportpcePceListener> pcelistenerRegistration;
private ListenerRegistration<TransportpceRendererListener> rendererlistenerRegistration;
private ListenerRegistration<TransportpceServicehandlerListener> servicehandlerlistenerRegistration;
rpcProviderService.registerRpcImplementation(TapiTopologyService.class, topo);
rpcProviderService.registerRpcImplementation(TapiCommonService.class, topo);
+ this.listeners = new ArrayList<>();
TapiNetconfTopologyListener topologyListener = new TapiNetconfTopologyListener(tapiNetworkModelServiceImpl);
TapiOrLinkListener orLinkListener = new TapiOrLinkListener(tapiLink, networkTransactionService);
TapiPortMappingListener tapiPortMappingListener = new TapiPortMappingListener(tapiNetworkModelServiceImpl);
- dataTreeChangeListenerRegistration1 =
- dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
- LINK_II), orLinkListener);
- dataTreeChangeListenerRegistration =
- dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifiers.NETCONF_TOPOLOGY_II.child(Node.class)), topologyListener);
- mappingListenerListenerRegistration =
- dataBroker.registerDataTreeChangeListener(DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
- MAPPING_II), tapiPortMappingListener);
+ listeners.add(dataBroker.registerDataTreeChangeListener(
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, LINK_II), orLinkListener));
+ listeners.add(dataBroker.registerDataTreeChangeListener(
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, InstanceIdentifiers.NETCONF_TOPOLOGY_II
+ .child(Node.class)),
+ topologyListener));
+ listeners.add(dataBroker.registerDataTreeChangeListener(
+ DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION, MAPPING_II), tapiPortMappingListener));
tapiNetworkutilsServiceRpcRegistration =
rpcProviderService.registerRpcImplementation(TransportpceTapinetworkutilsService.class,
this.tapiNetworkUtils);
TapiListener tapiListener = new TapiListener();
- dataBroker.registerDataTreeChangeListener(
+ listeners.add(dataBroker.registerDataTreeChangeListener(
DataTreeIdentifier.create(
LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(ServiceInterfacePoints.class)),
- tapiListener);
+ tapiListener));
// Notification Listener
pcelistenerRegistration = notificationService.registerNotificationListener(pceListenerImpl);
rendererlistenerRegistration = notificationService.registerNotificationListener(rendererListenerImpl);
*/
@Deactivate
public void close() {
- LOG.info("TapiProvider Session Closed");
- if (dataTreeChangeListenerRegistration != null) {
- dataTreeChangeListenerRegistration.close();
- }
- if (mappingListenerListenerRegistration != null) {
- mappingListenerListenerRegistration.close();
- }
- if (dataTreeChangeListenerRegistration1 != null) {
- dataTreeChangeListenerRegistration1.close();
- }
+ listeners.forEach(lis -> lis.close());
+ listeners.clear();
if (tapiNetworkutilsServiceRpcRegistration != null) {
tapiNetworkutilsServiceRpcRegistration.close();
}
servicehandlerlistenerRegistration.close();
rpcRegistration.close();
tapinetworkmodellistenerRegistration.close();
+ LOG.info("TapiProvider Session Closed");
}
}
package org.opendaylight.transportpce.tapi.provider;
import static org.mockito.ArgumentMatchers.any;
+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 static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
-import org.junit.jupiter.api.BeforeAll;
+import com.google.common.util.concurrent.Futures;
+import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
-import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations;
import org.opendaylight.transportpce.tapi.impl.TapiProvider;
import org.opendaylight.transportpce.tapi.topology.TapiNetworkModelService;
-import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.TransportpceTapinetworkutilsService;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.OrgOpenroadmServiceService;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.TapiCommonService;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.TapiTopologyService;
@ExtendWith(MockitoExtension.class)
-public class TapiProviderTest extends AbstractTest {
- private static NetworkTransactionService networkTransactionService;
+public class TapiProviderTest {
+ @Mock
+ private DataBroker dataBroker;
@Mock
private RpcProviderService rpcProviderRegistry;
@Mock
@Mock
private NotificationPublishService notificationPublishService;
@Mock
+ private NetworkTransactionService networkTransactionService;
+ @Mock
private OrgOpenroadmServiceService serviceHandler;
@Mock
private ServiceDataStoreOperations serviceDataStoreOperations;
@Mock
private TapiNetworkModelService tapiNetworkModelServiceImpl;
- @BeforeAll
- static void setUp() {
- networkTransactionService = new NetworkTransactionImpl(getDataBroker());
- }
-
@Test
void testInitRegisterTapiToRpcRegistry() {
- TapiProvider provider = new TapiProvider(getDataBroker(), rpcProviderRegistry, notificationService,
- notificationPublishService, networkTransactionService, serviceHandler, serviceDataStoreOperations,
- tapiNetworkUtils, tapiNetworkModelListenerImpl, tapiNetworkModelServiceImpl);
+ when(networkTransactionService.read(any(), any())).thenReturn(Futures.immediateFuture(Optional.empty()));
+ doReturn(emptyFluentFuture()).when(networkTransactionService).commit();
+ new TapiProvider(dataBroker, rpcProviderRegistry, notificationService, notificationPublishService,
+ networkTransactionService, serviceHandler, serviceDataStoreOperations, tapiNetworkUtils,
+ tapiNetworkModelListenerImpl, tapiNetworkModelServiceImpl);
verify(rpcProviderRegistry, times(1)).registerRpcImplementation(any(), any(TapiConnectivityService.class));
verify(rpcProviderRegistry, times(2)).registerRpcImplementation(any(), any(TapiTopologyService.class));
verify(rpcProviderRegistry, times(2)).registerRpcImplementation(any(), any(TapiCommonService.class));
+ verify(dataBroker, times(4)).registerDataTreeChangeListener(any(), any());
}
}
\ No newline at end of file