import org.opendaylight.transportpce.networkmodel.R2RLinkDiscovery;
import org.opendaylight.transportpce.networkmodel.service.NetworkModelService;
import org.opendaylight.transportpce.networkmodel.service.NetworkModelServiceImpl;
+import org.opendaylight.transportpce.networkmodel.service.NetworkModelWavelengthService;
+import org.opendaylight.transportpce.networkmodel.service.NetworkModelWavelengthServiceImpl;
import org.opendaylight.transportpce.olm.OlmPowerServiceRpcImpl;
import org.opendaylight.transportpce.olm.OlmProvider;
import org.opendaylight.transportpce.olm.power.PowerMgmt;
import org.opendaylight.transportpce.pce.impl.PceProvider;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.pce.service.PathComputationServiceImpl;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthServiceImpl;
import org.opendaylight.transportpce.renderer.RendererProvider;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221;
PortMapping portMapping = initPortMapping(lightyServices, openRoadmInterfaces);
NetworkModelService networkModelService = new NetworkModelServiceImpl(networkTransaction, linkDiscoveryImpl,
portMapping);
+ NetworkModelWavelengthService networkModelWavelengthService =
+ new NetworkModelWavelengthServiceImpl(lightyServices.getBindingDataBroker());
NetConfTopologyListener netConfTopologyListener = new NetConfTopologyListener(networkModelService,
lightyServices.getBindingDataBroker(), deviceTransactionManager);
networkModelProvider = new NetworkModelProvider(networkTransaction, lightyServices.getBindingDataBroker(),
- lightyServices.getRpcProviderService(), networkutilsServiceImpl, netConfTopologyListener);
+ lightyServices.getRpcProviderService(), networkutilsServiceImpl, netConfTopologyListener,
+ lightyServices.getNotificationService(), networkModelWavelengthService);
LOG.info("Creating OLM beans ...");
CrossConnect crossConnect = initCrossConnect(mappingUtils);
openRoadmInterfaces, crossConnect, portMapping, networkModelService);
OtnDeviceRendererService otnDeviceRendererService = new OtnDeviceRendererServiceImpl(openRoadmInterfaceFactory,
crossConnect, openRoadmInterfaces, deviceTransactionManager, networkModelService);
- NetworkModelWavelengthService networkModelWavelengthService = new NetworkModelWavelengthServiceImpl(
- lightyServices.getBindingDataBroker());
- rendererProvider = initRenderer(lightyServices, olmPowerServiceRpc, networkModelWavelengthService,
- deviceRendererService, otnDeviceRendererService);
+ rendererProvider = initRenderer(lightyServices, olmPowerServiceRpc, deviceRendererService,
+ otnDeviceRendererService);
LOG.info("Creating service-handler beans ...");
RendererServiceOperations rendererServiceOperations = new RendererServiceOperationsImpl(deviceRendererService,
otnDeviceRendererService, olmPowerServiceRpc, lightyServices.getBindingDataBroker(),
- networkModelWavelengthService, lightyServices.getBindingNotificationPublishService());
+ lightyServices.getBindingNotificationPublishService());
servicehandlerProvider = new ServicehandlerProvider(lightyServices.getBindingDataBroker(),
lightyServices.getRpcProviderService(), lightyServices.getNotificationService(), pathComputationService,
- rendererServiceOperations, networkModelWavelengthService,
- lightyServices.getBindingNotificationPublishService());
- tapiProvider = initTapi(lightyServices, rendererServiceOperations, networkModelWavelengthService,
- pathComputationService);
+ rendererServiceOperations, lightyServices.getBindingNotificationPublishService());
+ tapiProvider = initTapi(lightyServices, rendererServiceOperations, pathComputationService);
}
@Override
*
* @param lightyServices LightyServices
* @param rendererServiceOperations RendererServiceOperations
- * @param networkModelWavelengthService NetworkModelWavelengthService
* @return TapiProvider instance
*/
private TapiProvider initTapi(LightyServices lightyServices, RendererServiceOperations rendererServiceOperations,
- NetworkModelWavelengthService networkModelWavelengthService,
PathComputationService pathComputationService) {
RendererListenerImpl rendererListenerImpl = new RendererListenerImpl(pathComputationService,
lightyServices.getBindingNotificationPublishService());
lightyServices.getBindingNotificationPublishService(), serviceDataStoreOperations);
ServiceHandlerOperations serviceHandlerOperations = new ServiceHandlerOperationsImpl(
lightyServices.getBindingDataBroker(), pathComputationService, rendererServiceOperations,
- lightyServices.getBindingNotificationPublishService(), pceListenerImpl, rendererListenerImpl,
- networkModelWavelengthService);
+ lightyServices.getBindingNotificationPublishService(), pceListenerImpl, rendererListenerImpl);
return new TapiProvider(lightyServices.getBindingDataBroker(), lightyServices.getRpcProviderService(),
serviceHandlerOperations, new TapiListener());
}
*
* @param lightyServices LightyServices
* @param olmPowerServiceRpc TransportpceOlmService
- * @param networkModelWavelengthService NetworkModelWavelengthService
* @param deviceRendererService DeviceRendererService
* @param otnDeviceRendererService OtnDeviceRendererService
* @return RendererProvider instance
*/
private RendererProvider initRenderer(LightyServices lightyServices, TransportpceOlmService olmPowerServiceRpc,
- NetworkModelWavelengthService networkModelWavelengthService, DeviceRendererService deviceRendererService,
- OtnDeviceRendererService otnDeviceRendererService) {
+ DeviceRendererService deviceRendererService, OtnDeviceRendererService otnDeviceRendererService) {
DeviceRendererRPCImpl deviceRendererRPC = new DeviceRendererRPCImpl(deviceRendererService,
otnDeviceRendererService);
RendererServiceOperationsImpl rendererServiceOperations = new RendererServiceOperationsImpl(
deviceRendererService, otnDeviceRendererService, olmPowerServiceRpc,
- lightyServices.getBindingDataBroker(), networkModelWavelengthService,
- lightyServices.getBindingNotificationPublishService());
+ lightyServices.getBindingDataBroker(), lightyServices.getBindingNotificationPublishService());
return new RendererProvider(lightyServices.getRpcProviderService(), deviceRendererRPC,
rendererServiceOperations);
}
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.InstanceIdentifiers;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
+import org.opendaylight.transportpce.networkmodel.listeners.ServiceHandlerListener;
+import org.opendaylight.transportpce.networkmodel.service.NetworkModelWavelengthService;
import org.opendaylight.transportpce.networkmodel.util.TpceNetwork;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev170818.TransportpceNetworkutilsService;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.TransportpceServicehandlerListener;
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;
private ListenerRegistration<NetConfTopologyListener> dataTreeChangeListenerRegistration;
private ObjectRegistration<TransportpceNetworkutilsService> networkutilsServiceRpcRegistration;
private TpceNetwork tpceNetwork;
+ private ListenerRegistration<TransportpceServicehandlerListener> serviceHandlerListenerRegistration;
+ private NotificationService notificationService;
+ private NetworkModelWavelengthService networkModelWavelengthService;
public NetworkModelProvider(NetworkTransactionService networkTransactionService, final DataBroker dataBroker,
final RpcProviderService rpcProviderService, final TransportpceNetworkutilsService networkutilsService,
- final NetConfTopologyListener topologyListener) {
+ final NetConfTopologyListener topologyListener, NotificationService notificationService,
+ NetworkModelWavelengthService networkModelWavelengthService) {
this.dataBroker = dataBroker;
this.rpcProviderService = rpcProviderService;
this.networkutilsService = networkutilsService;
this.topologyListener = topologyListener;
this.tpceNetwork = new TpceNetwork(networkTransactionService);
+ this.notificationService = notificationService;
+ this.networkModelWavelengthService = networkModelWavelengthService;
}
/**
InstanceIdentifiers.NETCONF_TOPOLOGY_II.child(Node.class)), topologyListener);
networkutilsServiceRpcRegistration =
rpcProviderService.registerRpcImplementation(TransportpceNetworkutilsService.class, networkutilsService);
+ TransportpceServicehandlerListener serviceHandlerListner =
+ new ServiceHandlerListener(networkModelWavelengthService);
+ serviceHandlerListenerRegistration = notificationService.registerNotificationListener(serviceHandlerListner);
}
/**
if (networkutilsServiceRpcRegistration != null) {
networkutilsServiceRpcRegistration.close();
}
+ serviceHandlerListenerRegistration.close();
}
}
--- /dev/null
+/*
+ * Copyright © 2020 Orange, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.transportpce.networkmodel.listeners;
+
+import org.opendaylight.transportpce.networkmodel.service.NetworkModelWavelengthService;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.ServiceRpcResultSh;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.TransportpceServicehandlerListener;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.ServiceNotificationTypes;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.RpcStatusEx;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ServiceHandlerListener implements TransportpceServicehandlerListener {
+ private static final Logger LOG = LoggerFactory.getLogger(ServiceHandlerListener.class);
+ private final NetworkModelWavelengthService service;
+
+ public ServiceHandlerListener(NetworkModelWavelengthService service) {
+ LOG.info("Init service handler listener for network");
+ this.service = service;
+ }
+
+ @Override
+ public void onServiceRpcResultSh(ServiceRpcResultSh notification) {
+ if (notification.getStatus() != RpcStatusEx.Successful) {
+ LOG.info("RpcStatusEx of notification not equals successful. Nothing to do for notification {}",
+ notification);
+ return;
+ }
+ ServiceNotificationTypes notificationType = notification.getNotificationType();
+ if (notificationType == null) {
+ LOG.warn("No information about the type of the notification for {}", notification);
+ return;
+ }
+ switch (notificationType) {
+ case ServiceCreateResult:
+ case ServiceReconfigureResult:
+ case ServiceRestorationResult:
+ LOG.info("Service creation or reconfiguration or restoration notification received {}", notification);
+ onServiceCreation(notification);
+ break;
+ case ServiceDeleteResult:
+ LOG.info("Service delete notification received {}", notification);
+ onServiceDeletion(notification);
+ break;
+ default:
+ LOG.warn("This type of notification is not managed at this time {} for notification {}",
+ notificationType, notification);
+ break;
+
+ }
+ }
+
+ /**
+ * Allocate wavelength in topology.
+ * @param notification ServiceRpcResultSh
+ */
+ private void onServiceCreation(ServiceRpcResultSh notification) {
+ if (notification.getAToZDirection() != null || notification.getZToADirection() != null) {
+ LOG.info("Update topology with used frequency by service {}", notification.getServiceName());
+ service.useWavelengths(notification.getAToZDirection(), notification.getZToADirection());
+ }
+ }
+
+ /**
+ * Release wavelength in topology.
+ * @param notification ServiceRpcResultSh
+ */
+ private void onServiceDeletion(ServiceRpcResultSh notification) {
+ if (notification.getAToZDirection() != null || notification.getZToADirection() != null) {
+ LOG.info("Update topology with no more used frequency by deleted service {}",
+ notification.getServiceName());
+ service.freeWavelengths(notification.getAToZDirection(), notification.getZToADirection());
+ }
+ }
+
+}
--- /dev/null
+/*
+ * Copyright © 2017 AT&T and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.transportpce.networkmodel.service;
+
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.AToZDirection;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.ZToADirection;
+
+public interface NetworkModelWavelengthService {
+
+ /**
+ * Remove wavelength from available and add it to used wavelength list.
+ *
+ * @param atoZDirection AToZDirection: a to z path
+ * @param ztoADirection ZToADirection: z to a path
+ */
+ void useWavelengths(AToZDirection atoZDirection, ZToADirection ztoADirection);
+
+ /**
+ * Remove wavelength from used and add it to available wavelength list.
+ *
+ * @param atoZDirection AToZDirection: a to z path
+ * @param ztoADirection ZToADirection: z to a path
+ */
+ void freeWavelengths(AToZDirection atoZDirection, ZToADirection ztoADirection);
+
+}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.transportpce.renderer;
+package org.opendaylight.transportpce.networkmodel.service;
import java.math.BigDecimal;
import java.util.Collection;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.available.freq.map.AvailFreqMapsKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev200529.xpdr.port.connection.attributes.Wavelength;
import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev200529.xpdr.port.connection.attributes.WavelengthBuilder;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.PathDescription;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.AToZDirection;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.ZToADirection;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.atoz.direction.AToZ;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.ztoa.direction.ZToA;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.pce.resource.resource.resource.TerminationPoint;
}
@Override
- public void useWavelengths(PathDescription pathDescription) {
- List<NodeIdPair> atozTpIds = getAToZTpList(pathDescription);
- atozTpIds.removeIf(Objects::isNull);
- deleteAvailableWL(atozTpIds.stream().map(NodeIdPair::getNodeID).distinct().collect(Collectors.toList()),
- pathDescription.getAToZDirection().getAToZWavelengthNumber().toJava());
- List<NodeIdPair> ztoaTpIds = getZToATpList(pathDescription);
- ztoaTpIds.removeIf(Objects::isNull);
- deleteAvailableWL(ztoaTpIds.stream().map(NodeIdPair::getNodeID).distinct().collect(Collectors.toList()),
- pathDescription.getZToADirection().getZToAWavelengthNumber().toJava());
- addUsedWL(pathDescription.getAToZDirection().getAToZWavelengthNumber().toJava(), atozTpIds);
- addUsedWL(pathDescription.getZToADirection().getZToAWavelengthNumber().toJava(), ztoaTpIds);
+ public void useWavelengths(AToZDirection atoZDirection, ZToADirection ztoADirection) {
+ if (atoZDirection != null && atoZDirection.getAToZWavelengthNumber() != null) {
+ LOG.info("Update wavelength for a to z direction {}", atoZDirection);
+ List<NodeIdPair> atozTpIds = getAToZTpList(atoZDirection);
+ atozTpIds.removeIf(Objects::isNull);
+ deleteAvailableWL(atozTpIds.stream().map(NodeIdPair::getNodeID).distinct().collect(Collectors.toList()),
+ atoZDirection.getAToZWavelengthNumber().toJava());
+ addUsedWL(atoZDirection.getAToZWavelengthNumber().toJava(), atozTpIds);
+ }
+ if (ztoADirection != null && ztoADirection.getZToAWavelengthNumber() != null) {
+ LOG.info("Update wavelength for z to a direction {}", ztoADirection);
+ List<NodeIdPair> ztoaTpIds = getZToATpList(ztoADirection);
+ ztoaTpIds.removeIf(Objects::isNull);
+ deleteAvailableWL(ztoaTpIds.stream().map(NodeIdPair::getNodeID).distinct().collect(Collectors.toList()),
+ ztoADirection.getZToAWavelengthNumber().toJava());
+
+ addUsedWL(ztoADirection.getZToAWavelengthNumber().toJava(), ztoaTpIds);
+ }
}
+
@Override
- public void freeWavelengths(PathDescription pathDescription) {
- List<NodeIdPair> atozTpIds = getAToZTpList(pathDescription);
- List<NodeIdPair> ztoaTpIds = getZToATpList(pathDescription);
- atozTpIds.removeIf(Objects::isNull);
- ztoaTpIds.removeIf(Objects::isNull);
- deleteUsedWL(pathDescription.getAToZDirection().getAToZWavelengthNumber().toJava(), atozTpIds);
- deleteUsedWL(pathDescription.getZToADirection().getZToAWavelengthNumber().toJava(), ztoaTpIds);
- addAvailableWL(atozTpIds.stream().map(NodeIdPair::getNodeID).distinct().collect(Collectors.toList()),
- pathDescription.getAToZDirection().getAToZWavelengthNumber().toJava());
- addAvailableWL(ztoaTpIds.stream().map(NodeIdPair::getNodeID).distinct().collect(Collectors.toList()),
- pathDescription.getZToADirection().getZToAWavelengthNumber().toJava());
+ public void freeWavelengths(AToZDirection atoZDirection, ZToADirection ztoADirection) {
+ if (atoZDirection != null && atoZDirection.getAToZWavelengthNumber() != null) {
+ LOG.info("Free wavelength for a to z direction {}", atoZDirection);
+ List<NodeIdPair> atozTpIds = getAToZTpList(atoZDirection);
+ atozTpIds.removeIf(Objects::isNull);
+ deleteUsedWL(atoZDirection.getAToZWavelengthNumber().toJava(), atozTpIds);
+ addAvailableWL(atozTpIds.stream().map(NodeIdPair::getNodeID).distinct().collect(Collectors.toList()),
+ atoZDirection.getAToZWavelengthNumber().toJava());
+ }
+ if (ztoADirection != null && ztoADirection.getZToAWavelengthNumber() != null) {
+ LOG.info("Free wavelength for z to a direction {}", ztoADirection);
+ List<NodeIdPair> ztoaTpIds = getZToATpList(ztoADirection);
+ ztoaTpIds.removeIf(Objects::isNull);
+ deleteUsedWL(ztoADirection.getZToAWavelengthNumber().toJava(), ztoaTpIds);
+ addAvailableWL(ztoaTpIds.stream().map(NodeIdPair::getNodeID).distinct().collect(Collectors.toList()),
+ ztoADirection.getZToAWavelengthNumber().toJava());
+ }
}
- private List<NodeIdPair> getAToZTpList(PathDescription pathDescription) {
- Collection<AToZ> atozList = pathDescription.getAToZDirection().nonnullAToZ().values();
+ private List<NodeIdPair> getAToZTpList(AToZDirection atoZDirection) {
+ Collection<AToZ> atozList = atoZDirection.nonnullAToZ().values();
return atozList.stream()
.filter(aToZ -> {
if ((aToZ.getResource() == null) || (aToZ.getResource().getResource() == null)) {
}).collect(Collectors.toList());
}
- private List<NodeIdPair> getZToATpList(PathDescription pathDescription) {
- Collection<ZToA> ztoaList = pathDescription.getZToADirection().nonnullZToA().values();
+ private List<NodeIdPair> getZToATpList(ZToADirection ztoADirection) {
+ Collection<ZToA> ztoaList = ztoADirection.nonnullZToA().values();
return ztoaList.stream()
.filter(zToA -> {
if ((zToA.getResource() == null) || (zToA.getResource().getResource() == null)) {
<reference id="portMapping" interface="org.opendaylight.transportpce.common.mapping.PortMapping" />
<reference id="networkTransactionImpl" interface="org.opendaylight.transportpce.common.network.NetworkTransactionService" />
<reference id="mappingUtils" interface="org.opendaylight.transportpce.common.mapping.MappingUtils" />
+ <reference id="notificationService" interface="org.opendaylight.mdsal.binding.api.NotificationService"/>
<bean id="networkModelService" class="org.opendaylight.transportpce.networkmodel.service.NetworkModelServiceImpl">
<argument ref="networkTransactionImpl" />
<argument ref="rpcProviderService" />
<argument ref="networkutilsServiceImpl" />
<argument ref="netconfTopologyListener" />
+ <argument ref="notificationService" />
+ <argument ref="networkModelWavelengthService" />
</bean>
<bean id="netconfTopologyListener" class="org.opendaylight.transportpce.networkmodel.NetConfTopologyListener">
<argument ref="networkTransactionImpl" />
</bean>
+ <bean id="networkModelWavelengthService" class="org.opendaylight.transportpce.networkmodel.service.NetworkModelWavelengthServiceImpl">
+ <argument ref="dataBroker" />
+ </bean>
+
<service ref="networkModelService" interface="org.opendaylight.transportpce.networkmodel.service.NetworkModelService" />
+ <service ref="networkModelWavelengthService" interface="org.opendaylight.transportpce.networkmodel.service.NetworkModelWavelengthService" />
+
</blueprint>
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710;
import org.opendaylight.transportpce.networkmodel.service.NetworkModelService;
-import org.opendaylight.transportpce.networkmodel.stub.MountPointServiceStub;
-import org.opendaylight.transportpce.networkmodel.stub.MountPointStub;
import org.opendaylight.transportpce.test.DataStoreContextImpl;
+import org.opendaylight.transportpce.test.stub.MountPointServiceStub;
+import org.opendaylight.transportpce.test.stub.MountPointStub;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Host;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
+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.NetworkModelWavelengthService;
import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.networkutils.rev170818.TransportpceNetworkutilsService;
TransportpceNetworkutilsService networkutilsService;
@Mock
NetConfTopologyListener topologyListener;
+ @Mock
+ private NotificationService notificationService;
+ @Mock
+ private NetworkModelWavelengthService networkModelWavelengthService;
@Test
public void networkmodelProviderInitTest() {
NetworkModelProvider provider = new NetworkModelProvider(networkTransactionService, getDataBroker(),
- rpcProviderService, networkutilsService, topologyListener);
+ rpcProviderService, networkutilsService, topologyListener, notificationService,
+ networkModelWavelengthService);
Answer<FluentFuture<CommitInfo>> answer = new Answer<FluentFuture<CommitInfo>>() {
@Override
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.transportpce.renderer;
+package org.opendaylight.transportpce.networkmodel.service;
import java.math.BigDecimal;
import java.util.ArrayList;
import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl;
import org.opendaylight.transportpce.common.fixedflex.FixedGridConstant;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
-import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub;
-import org.opendaylight.transportpce.renderer.stub.MountPointStub;
-import org.opendaylight.transportpce.renderer.utils.ServiceDeleteDataUtils;
-import org.opendaylight.transportpce.renderer.utils.WaveLengthServiceUtils;
+import org.opendaylight.transportpce.networkmodel.util.WaveLengthServiceUtils;
+import org.opendaylight.transportpce.networkmodel.util.test.PathDescriptionUtils;
import org.opendaylight.transportpce.test.AbstractTest;
+import org.opendaylight.transportpce.test.stub.MountPointServiceStub;
+import org.opendaylight.transportpce.test.stub.MountPointStub;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyGHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyTHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev200529.Node1;
List<Object[]> parameters = new ArrayList<>();
PathDescription pathDescription =
- ServiceDeleteDataUtils.createTransactionPathDescription(StringConstants.TTP_TOKEN);
+ PathDescriptionUtils.createTransactionPathDescription(StringConstants.TTP_TOKEN);
FixedFlexImpl fixedFlex = new FixedFlexImpl();
fixedFlex = fixedFlex.getFixedFlexWaveMapping(WAVE_LENGTH);
@Before
public void setMountPoint() {
- MountPointServiceStub mountPointService = new MountPointServiceStub(new MountPointStub(this.getDataBroker()));
+ MountPointServiceStub mountPointService = new MountPointServiceStub(new MountPointStub(getDataBroker()));
this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000);
- networkModelWavelengthService = new NetworkModelWavelengthServiceImpl(this.getDataBroker());
+ networkModelWavelengthService = new NetworkModelWavelengthServiceImpl(getDataBroker());
}
@Test
WaveLengthServiceUtils.putTerminationPoint1ToDatastore("node1" + StringConstants.TTP_TOKEN,
StringConstants.TTP_TOKEN, this.terminationPoint1, this.deviceTransactionManager);
WaveLengthServiceUtils.putTerminationPoint2ToDatastore("node1" + StringConstants.TTP_TOKEN,
- StringConstants.TTP_TOKEN, this.terminationPoint2, this.deviceTransactionManager);
+ StringConstants.TTP_TOKEN, this.terminationPoint2);
WaveLengthServiceUtils.putNode1ToDatastore("node1" + StringConstants.TTP_TOKEN, this.node1,
this.deviceTransactionManager);
- WaveLengthServiceUtils.putNode2ToDatastore("node1" + StringConstants.TTP_TOKEN, this.node2,
- this.deviceTransactionManager);
- this.networkModelWavelengthService.freeWavelengths(this.pathDescription);
+ WaveLengthServiceUtils.putNode2ToDatastore("node1" + StringConstants.TTP_TOKEN, this.node2);
+ this.networkModelWavelengthService.freeWavelengths(this.pathDescription.getAToZDirection(),
+ this.pathDescription.getZToADirection());
Node1 updatedNode1 = WaveLengthServiceUtils.getNode1FromDatastore("node1" + StringConstants.TTP_TOKEN,
this.deviceTransactionManager);
org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1 updatedNode2 =
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.transportpce.renderer;
+package org.opendaylight.transportpce.networkmodel.service;
import java.math.BigDecimal;
import java.util.ArrayList;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
import org.opendaylight.transportpce.common.fixedflex.FixedGridConstant;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
-import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub;
-import org.opendaylight.transportpce.renderer.stub.MountPointStub;
-import org.opendaylight.transportpce.renderer.utils.ServiceDeleteDataUtils;
-import org.opendaylight.transportpce.renderer.utils.WaveLengthServiceUtils;
+import org.opendaylight.transportpce.networkmodel.util.WaveLengthServiceUtils;
+import org.opendaylight.transportpce.networkmodel.util.test.PathDescriptionUtils;
import org.opendaylight.transportpce.test.AbstractTest;
+import org.opendaylight.transportpce.test.stub.MountPointServiceStub;
+import org.opendaylight.transportpce.test.stub.MountPointStub;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyGHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyTHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev200529.Node1;
@Before
public void setMountPoint() {
- MountPointServiceStub mountPointService = new MountPointServiceStub(new MountPointStub(this.getDataBroker()));
+ MountPointServiceStub mountPointService = new MountPointServiceStub(new MountPointStub(getDataBroker()));
this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000);
- networkModelWavelengthService = new NetworkModelWavelengthServiceImpl(this.getDataBroker());
+ networkModelWavelengthService = new NetworkModelWavelengthServiceImpl(getDataBroker());
}
public NetworkModelWaveLengthServiceUseTest(PathDescription pathDescription, TerminationPoint1 terminationPoint1,
List<Object[]> parameters = new ArrayList<>();
PathDescription pathDescription =
- ServiceDeleteDataUtils.createTransactionPathDescription(StringConstants.TTP_TOKEN);
+ PathDescriptionUtils.createTransactionPathDescription(StringConstants.TTP_TOKEN);
TerminationPoint1Builder terminationPoint1Builder = new TerminationPoint1Builder()
.setCtpAttributes((new CtpAttributesBuilder()).setAvailFreqMaps(Map.of()).build())
WaveLengthServiceUtils.putTerminationPoint1ToDatastore("node1" + StringConstants.TTP_TOKEN,
StringConstants.TTP_TOKEN, this.terminationPoint1, this.deviceTransactionManager);
WaveLengthServiceUtils.putTerminationPoint2ToDatastore("node1" + StringConstants.TTP_TOKEN,
- StringConstants.TTP_TOKEN, this.terminatPoint2, this.deviceTransactionManager);
+ StringConstants.TTP_TOKEN, this.terminatPoint2);
WaveLengthServiceUtils.putNode1ToDatastore("node1" + StringConstants.TTP_TOKEN, this.node1,
this.deviceTransactionManager);
- WaveLengthServiceUtils.putNode2ToDatastore("node1" + StringConstants.TTP_TOKEN, this.node2,
- this.deviceTransactionManager);
- this.networkModelWavelengthService.useWavelengths(this.pathDescription);
+ WaveLengthServiceUtils.putNode2ToDatastore("node1" + StringConstants.TTP_TOKEN, this.node2);
+ this.networkModelWavelengthService.useWavelengths(this.pathDescription.getAToZDirection(),
+ this.pathDescription.getZToADirection());
Node1 updatedNode1 = WaveLengthServiceUtils.getNode1FromDatastore("node1" + StringConstants.TTP_TOKEN,
this.deviceTransactionManager);
org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1 updatedNode2 =
+++ /dev/null
-/*
- * Copyright © 2018 Orange Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.transportpce.networkmodel.stub;
-
-import java.util.Optional;
-import org.opendaylight.mdsal.binding.api.MountPoint;
-import org.opendaylight.mdsal.binding.api.MountPointService;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class MountPointServiceStub implements MountPointService {
-
- MountPoint returnedMountPoint;
-
- public MountPointServiceStub(MountPoint usedMountPoint) {
- this.returnedMountPoint = usedMountPoint;
- }
-
- @Override
- public Optional<MountPoint> getMountPoint(InstanceIdentifier<?> mountPoint) {
- if (returnedMountPoint == null) {
- return Optional.empty();
- }
- return Optional.of(returnedMountPoint);
- }
-
- @Override
- public <T extends MountPointListener> ListenerRegistration<T> registerListener(InstanceIdentifier<?> path,
- T listener) {
- return null;
- }
-}
+++ /dev/null
-/*
- * Copyright © 2018 Orange Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.transportpce.networkmodel.stub;
-
-import java.util.Optional;
-import javax.annotation.Nonnull;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.api.BindingService;
-import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.MountPoint;
-import org.opendaylight.mdsal.binding.api.NotificationService;
-import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.NotificationListener;
-
-
-public class MountPointStub implements MountPoint {
-
- private DataBroker dataBroker;
-
- private RpcConsumerRegistry rpcConsumerRegistry;
-
-
- private NotificationService notificationService = new NotificationService() {
- @Override
- public @NonNull <T extends NotificationListener> ListenerRegistration<T>
- registerNotificationListener(@NonNull T listener) {
- return null;
- }
- };
-
- public MountPointStub(DataBroker dataBroker) {
- this.dataBroker = dataBroker;
- }
-
- public void setRpcConsumerRegistry(
- RpcConsumerRegistry rpcConsumerRegistry) {
- this.rpcConsumerRegistry = rpcConsumerRegistry;
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public <T extends BindingService> Optional<T> getService(Class<T> service) {
- if (service.isInstance(dataBroker)) {
- return Optional.ofNullable((T) dataBroker);
- }
- if (service.isInstance(rpcConsumerRegistry)) {
- return Optional.ofNullable((T) rpcConsumerRegistry);
- }
- if (service.isInstance(notificationService)) {
- return Optional.ofNullable((T) notificationService);
- }
- return Optional.empty();
- }
-
- @Nonnull
- @Override
- public InstanceIdentifier<?> getIdentifier() {
- throw new UnsupportedOperationException();
- }
-}
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.transportpce.renderer.utils;
+package org.opendaylight.transportpce.networkmodel.util;
import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
+import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev200529.Node1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev200529.TerminationPoint1;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
-public final class WaveLengthServiceUtils {
+public final class WaveLengthServiceUtils extends AbstractTest {
private WaveLengthServiceUtils() {
}
public static void putTerminationPoint1ToDatastore(String nodeId, String tpId, TerminationPoint1 terminationPoint1,
- DeviceTransactionManager deviceTransactionManager)
- throws ExecutionException, InterruptedException {
- TransactionUtils
- .writeTransaction(deviceTransactionManager, nodeId, LogicalDatastoreType.CONFIGURATION,
+ DeviceTransactionManager deviceTransactionManager) throws ExecutionException, InterruptedException {
+ WriteTransaction writeTransaction = getDataBroker().newWriteOnlyTransaction();
+ writeTransaction.put(LogicalDatastoreType.CONFIGURATION,
createTerminationPoint1IIDBuilder(nodeId, tpId).build(), terminationPoint1);
+ writeTransaction.commit();
}
public static void putTerminationPoint2ToDatastore(String nodeId, String tpId,
org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1
- terminationPoint1, DeviceTransactionManager deviceTransactionManager)
+ terminationPoint1)
throws ExecutionException, InterruptedException {
- TransactionUtils
- .writeTransaction(deviceTransactionManager, nodeId, LogicalDatastoreType.CONFIGURATION,
+ WriteTransaction writeTransaction = getDataBroker().newWriteOnlyTransaction();
+ writeTransaction.put(LogicalDatastoreType.CONFIGURATION,
createTerminationPoint2IIDBuilder(nodeId, tpId).build(), terminationPoint1);
+ writeTransaction.commit();
}
public static TerminationPoint1 getTerminationPoint1FromDatastore(String nodeId, String tpId,
DeviceTransactionManager deviceTransactionManager)
throws ExecutionException, InterruptedException {
InstanceIdentifier<TerminationPoint1> tpIID = createTerminationPoint1IIDBuilder(nodeId, tpId).build();
- return (TerminationPoint1) TransactionUtils
- .readTransaction(deviceTransactionManager, nodeId, LogicalDatastoreType.CONFIGURATION, tpIID);
+ return getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, tpIID).get().get();
}
public static org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
throws ExecutionException, InterruptedException {
InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1>
tpIID = createTerminationPoint2IIDBuilder(nodeId, tpId).build();
- return (org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.TerminationPoint1)
- TransactionUtils
- .readTransaction(deviceTransactionManager, nodeId, LogicalDatastoreType.CONFIGURATION, tpIID);
+ return getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, tpIID).get().get();
}
private static InstanceIdentifier<Node1> createNode1IID(String nodeId) {
DeviceTransactionManager deviceTransactionManager)
throws ExecutionException, InterruptedException {
InstanceIdentifier<Node1> nodeIID = createNode1IID(nodeId);
- TransactionUtils
- .writeTransaction(deviceTransactionManager, nodeId,
- LogicalDatastoreType.CONFIGURATION, nodeIID, node1);
+ WriteTransaction writeTransaction = getDataBroker().newWriteOnlyTransaction();
+ writeTransaction.put(LogicalDatastoreType.CONFIGURATION,nodeIID, node1);
+ writeTransaction.commit();
}
public static void putNode2ToDatastore(String nodeId,
- org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1 node1,
- DeviceTransactionManager deviceTransactionManager)
+ org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1 node1)
throws ExecutionException, InterruptedException {
InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1> nodeIID =
createNode2IID(nodeId);
- TransactionUtils
- .writeTransaction(deviceTransactionManager, nodeId,
- LogicalDatastoreType.CONFIGURATION, nodeIID, node1);
+ WriteTransaction writeTransaction = getDataBroker().newWriteOnlyTransaction();
+ writeTransaction.put(LogicalDatastoreType.CONFIGURATION,
+ nodeIID, node1);
+ writeTransaction.commit();
}
public static Node1 getNode1FromDatastore(String nodeId, DeviceTransactionManager deviceTransactionManager)
throws ExecutionException, InterruptedException {
InstanceIdentifier<Node1> nodeIID = createNode1IID(nodeId);
- return (Node1) TransactionUtils
- .readTransaction(deviceTransactionManager, nodeId, LogicalDatastoreType.CONFIGURATION, nodeIID);
+ return getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, nodeIID).get().get();
}
public static org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
throws ExecutionException, InterruptedException {
InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
.Node1> nodeIID = createNode2IID(nodeId);
- return (org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1) TransactionUtils
- .readTransaction(deviceTransactionManager, nodeId, LogicalDatastoreType.CONFIGURATION, nodeIID);
+ return getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION, nodeIID).get().get();
}
}
--- /dev/null
+/*
+ * Copyright © 2018 Orange Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.transportpce.networkmodel.util.test;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.port.PortBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.service.format.rev190531.ServiceFormat;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.AToZDirection;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.AToZDirectionBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.ZToADirection;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.ZToADirectionBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.atoz.direction.AToZ;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.atoz.direction.AToZBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.atoz.direction.AToZKey;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.ztoa.direction.ZToA;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.ztoa.direction.ZToABuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.ztoa.direction.ZToAKey;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.pce.resource.ResourceBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.pce.resource.resource.resource.TerminationPoint;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.pce.resource.resource.resource.TerminationPointBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.RxDirectionBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.TxDirectionBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.service.path.PathDescription;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.service.path.PathDescriptionBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.service.path.ServiceAEndBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.service.path.ServiceZEndBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
+
+public final class PathDescriptionUtils {
+
+ private PathDescriptionUtils() {
+
+ }
+
+ public static PathDescription createTransactionPathDescription(String tpId) {
+ Map<AToZKey,AToZ> atoZMap = new HashMap<>();
+ TerminationPointBuilder terminationPointBuilder = new TerminationPointBuilder();
+ TerminationPoint terminationPoint = terminationPointBuilder.setTpNodeId("node2" + tpId)
+ .setTpId(tpId).build();
+ TerminationPoint terminationPoint2 = terminationPointBuilder.setTpNodeId("node1" + tpId)
+ .setTpId(tpId).build();
+ AToZ atoZ = new AToZBuilder().setId("1").withKey(new AToZKey("1")).setResource(new ResourceBuilder()
+ .setResource(terminationPoint).build()).build();
+ AToZ atoZ2 = new AToZBuilder().setId("2").withKey(new AToZKey("2")).setResource(new ResourceBuilder()
+ .setResource(terminationPoint2).build()).build();
+ atoZMap.put(atoZ.key(),atoZ);
+ atoZMap.put(atoZ2.key(),atoZ2);
+ AToZDirection atozDirection = new AToZDirectionBuilder()
+ .setRate(Uint32.valueOf(20))
+ .setAToZWavelengthNumber(Uint32.valueOf(20))
+ .setAToZ(atoZMap)
+ .setModulationFormat("OC")
+ .build();
+ Map<ZToAKey,ZToA> ztoAMap = new HashMap<>();
+ ZToA ztoA = new ZToABuilder().setId("1").withKey(new ZToAKey("1")).setResource(new ResourceBuilder()
+ .setResource(terminationPoint).build()).build();
+ ZToA ztoA2 = new ZToABuilder().setId("2").withKey(new ZToAKey("2")).setResource(new ResourceBuilder()
+ .setResource(terminationPoint).build()).build();
+ ztoAMap.put(ztoA.key(),ztoA);
+ ztoAMap.put(ztoA2.key(),ztoA2);
+ ZToADirection ztoaDirection = new ZToADirectionBuilder()
+ .setRate(Uint32.valueOf(20))
+ .setZToAWavelengthNumber(Uint32.valueOf(20))
+ .setZToA(ztoAMap)
+ .setModulationFormat("OC")
+ .build();
+ PathDescriptionBuilder pathDescriptionBuilder = new PathDescriptionBuilder();
+ pathDescriptionBuilder.setAToZDirection(atozDirection);
+ pathDescriptionBuilder.setZToADirection(ztoaDirection);
+ return pathDescriptionBuilder.build();
+ }
+
+ public static ServiceAEndBuilder getServiceAEndBuild() {
+ return new ServiceAEndBuilder()
+ .setClli("clli").setServiceFormat(ServiceFormat.OC)
+ .setServiceRate(Uint32.valueOf(1)).setNodeId("XPONDER-1-2")
+ .setTxDirection(
+ new TxDirectionBuilder()
+ .setPort(new PortBuilder().setPortDeviceName("device name").setPortName("port name")
+ .setPortRack("port rack").setPortShelf("port shelf").setPortSlot("port slot")
+ .setPortSubSlot("port subslot").setPortType("port type").build())
+ .build())
+ .setRxDirection(
+ new RxDirectionBuilder()
+ .setPort(new PortBuilder().setPortDeviceName("device name").setPortName("port name")
+ .setPortRack("port rack").setPortShelf("port shelf").setPortSlot("port slot")
+ .setPortSubSlot("port subslot").setPortType("port type").build())
+ .build());
+ }
+
+ public static ServiceZEndBuilder getServiceZEndBuild() {
+ return new ServiceZEndBuilder()
+ .setClli("clli").setServiceFormat(ServiceFormat.OC)
+ .setServiceRate(Uint32.valueOf(1)).setNodeId("XPONDER-2-3")
+ .setTxDirection(
+ new TxDirectionBuilder()
+ .setPort(new PortBuilder().setPortDeviceName("device name").setPortName("port name")
+ .setPortRack("port rack").setPortShelf("port shelf").setPortSlot("port slot")
+ .setPortSubSlot("port subslot").setPortType("port type").build())
+ .build())
+ .setRxDirection(
+ new RxDirectionBuilder()
+ .setPort(new PortBuilder().setPortDeviceName("device name").setPortName("port name")
+ .setPortRack("port rack").setPortShelf("port shelf").setPortSlot("port slot")
+ .setPortSubSlot("port subslot").setPortType("port type").build())
+ .build());
+ }
+}
+++ /dev/null
-/*
- * Copyright © 2017 AT&T and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.transportpce.renderer;
-
-import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.PathDescription;
-
-public interface NetworkModelWavelengthService {
-
- /**
- * Remove wavelength from available and add it to used wavelength list.
- *
- * @param pathDescription
- * path description containing a-to-z and z-to-a path
- */
- void useWavelengths(PathDescription pathDescription);
-
- /**
- * Remove wavelength from used and add it to available wavelength list.
- *
- * @param pathDescription
- * path description containing a-to-z and z-to-a path
- */
- void freeWavelengths(PathDescription pathDescription);
-
-}
private void createODU4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
-
+ if (input.getNodes() == null) {
+ return;
+ }
+ LOG.info("Creation of ODU4 tp interface {}", input);
for (int i = 0; i < input.getNodes().size(); i++) {
Nodes node = input.getNodes().get(i);
String supportingOtuInterface = node.getNetworkTp() + "-OTU";
package org.opendaylight.transportpce.renderer.provisiondevice;
import com.google.common.util.concurrent.ListenableFuture;
-import org.opendaylight.transportpce.common.OperationResult;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceDeleteInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceDeleteOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceImplementationRequestInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceImplementationRequestOutput;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.Services;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.PathDescription;
public interface RendererServiceOperations {
ListenableFuture<ServiceImplementationRequestOutput> serviceImplementation(ServiceImplementationRequestInput input);
ListenableFuture<ServiceDeleteOutput> serviceDelete(ServiceDeleteInput input, Services service);
-
- OperationResult reserveResource(PathDescription pathDescription);
-
- OperationResult freeResource(PathDescription pathDescription);
-
}
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.transportpce.common.OperationResult;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.renderer.ModelMappingUtils;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService;
import org.opendaylight.transportpce.renderer.ServicePathInputData;
import org.opendaylight.transportpce.renderer.provisiondevice.servicepath.ServicePathDirection;
import org.opendaylight.transportpce.renderer.provisiondevice.tasks.DeviceRenderingRollbackTask;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.olm.get.pm.input.ResourceIdentifierBuilder;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.olm.renderer.input.Nodes;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
private final DataBroker dataBroker;
private final NotificationPublishService notificationPublishService;
private ListeningExecutorService executor;
- private NetworkModelWavelengthService networkModelWavelengthService;
- private RendererRpcResultSp notification = null;
public RendererServiceOperationsImpl(DeviceRendererService deviceRenderer,
OtnDeviceRendererService otnDeviceRenderer, TransportpceOlmService olmService,
- DataBroker dataBroker, NetworkModelWavelengthService networkModelWavelengthService,
- NotificationPublishService notificationPublishService) {
+ DataBroker dataBroker, NotificationPublishService notificationPublishService) {
this.deviceRenderer = deviceRenderer;
this.otnDeviceRenderer = otnDeviceRenderer;
this.olmService = olmService;
this.dataBroker = dataBroker;
- this.networkModelWavelengthService = networkModelWavelengthService;
this.notificationPublishService = notificationPublishService;
this.executor = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUMBER_OF_THREADS));
}
- private void sendNotifications(ServicePathNotificationTypes servicePathNotificationTypes, String serviceName,
- RpcStatusEx rpcStatusEx, String message) {
- this.notification = new RendererRpcResultSpBuilder()
- .setNotificationType(servicePathNotificationTypes)
- .setServiceName(serviceName)
- .setStatus(rpcStatusEx)
- .setStatusMessage(message)
- .build();
- try {
- notificationPublishService.putNotification(this.notification);
- } catch (InterruptedException e) {
- LOG.info("notification offer rejected: ", e);
- }
- }
-
@Override
public ListenableFuture<ServiceImplementationRequestOutput>
serviceImplementation(ServiceImplementationRequestInput input) {
OPERATION_FAILED);
}
LOG.info("OTN rendering result size {}", otnRenderingResults.size());
- sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
- input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL);
}
break;
case Infrastructure:
OPERATION_FAILED);
}
LOG.info("OTN rendering result size {}", otnRenderingResults.size());
- sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
- input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL);
}
break;
default:
LOG.warn("Unsupported connection type {}", input.getConnectionType());
}
+ sendNotificationsWithPathDescription(
+ ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL,
+ input.getPathDescription());
return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_OK,
OPERATION_SUCCESSFUL);
}
});
}
- @Override
- @SuppressWarnings("checkstyle:IllegalCatch")
- public OperationResult reserveResource(PathDescription pathDescription) {
-
- try {
- LOG.info("Reserving resources in network model");
- networkModelWavelengthService.useWavelengths(pathDescription);
- } catch (Exception e) {
- LOG.warn("Reserving resources in network model failed");
- return OperationResult.failed("Resources reserve failed in network model");
- }
- return OperationResult.ok("Resources reserved successfully in network model");
- }
-
- @Override
- @SuppressWarnings("checkstyle:IllegalCatch")
- public OperationResult freeResource(PathDescription pathDescription) {
-
- try {
- networkModelWavelengthService.freeWavelengths(pathDescription);
- } catch (Exception e) {
- return OperationResult.failed("Resources reserve failed in network model");
- }
- return OperationResult.ok("Resources reserved successfully in network model");
- }
-
@Override
public ListenableFuture<ServiceDeleteOutput> serviceDelete(ServiceDeleteInput input, Services service) {
String serviceName = input.getServiceName();
"Service activation test failed.");
return false;
}
- // If Service activation is success update Network ModelMappingUtils
- networkModelWavelengthService.useWavelengths(input.getPathDescription());
- sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
- input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL);
+ sendNotificationsWithPathDescription(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL, input.getPathDescription());
return true;
}
"Deleting service path via renderer");
deviceRenderer.deleteServicePath(servicePathInputDataAtoZ.getServicePathInput());
deviceRenderer.deleteServicePath(servicePathInputDataZtoA.getServicePathInput());
- networkModelWavelengthService.freeWavelengths(pathDescription);
- sendNotifications(ServicePathNotificationTypes.ServiceDelete, serviceName, RpcStatusEx.Successful,
- OPERATION_SUCCESSFUL);
+ sendNotificationsWithPathDescription(ServicePathNotificationTypes.ServiceDelete,
+ serviceName, RpcStatusEx.Successful, OPERATION_SUCCESSFUL,pathDescription);
return true;
}
"Deleting otn-service path via renderer");
OtnServicePathOutput result = otnDeviceRenderer.deleteOtnServicePath(ospi);
if (result.isSuccess()) {
- sendNotifications(ServicePathNotificationTypes.ServiceDelete, serviceName, RpcStatusEx.Successful,
- OPERATION_SUCCESSFUL);
+ sendNotificationsWithPathDescription(ServicePathNotificationTypes.ServiceDelete,
+ serviceName, RpcStatusEx.Successful, OPERATION_SUCCESSFUL, pathDescription);
return true;
} else {
return false;
}
}
+ /**
+ * Send renderer notification.
+ * @param servicePathNotificationTypes ServicePathNotificationTypes
+ * @param serviceName String
+ * @param rpcStatusEx RpcStatusEx
+ * @param message String
+ */
+ private void sendNotifications(ServicePathNotificationTypes servicePathNotificationTypes, String serviceName,
+ RpcStatusEx rpcStatusEx, String message) {
+ Notification notification = buildNotification(servicePathNotificationTypes, serviceName, rpcStatusEx, message,
+ null);
+ send(notification);
+ }
+
+ /**
+ * Send renderer notification with path description information.
+ * @param servicePathNotificationTypes ServicePathNotificationTypes
+ * @param serviceName String
+ * @param rpcStatusEx RpcStatusEx
+ * @param message String
+ * @param pathDescription PathDescription
+ */
+ private void sendNotificationsWithPathDescription(ServicePathNotificationTypes servicePathNotificationTypes,
+ String serviceName, RpcStatusEx rpcStatusEx, String message, PathDescription pathDescription) {
+ Notification notification = buildNotification(servicePathNotificationTypes, serviceName, rpcStatusEx, message,
+ pathDescription);
+ send(notification);
+ }
+
+ /**
+ * Build notification containing path description information.
+ * @param servicePathNotificationTypes ServicePathNotificationTypes
+ * @param serviceName String
+ * @param rpcStatusEx RpcStatusEx
+ * @param message String
+ * @param pathDescription PathDescription
+ * @return notification with RendererRpcResultSp type.
+ */
+ private RendererRpcResultSp buildNotification(ServicePathNotificationTypes servicePathNotificationTypes,
+ String serviceName, RpcStatusEx rpcStatusEx, String message, PathDescription pathDescription) {
+ RendererRpcResultSpBuilder builder = new RendererRpcResultSpBuilder()
+ .setNotificationType(servicePathNotificationTypes).setServiceName(serviceName).setStatus(rpcStatusEx)
+ .setStatusMessage(message);
+ if (pathDescription != null) {
+ builder.setAToZDirection(pathDescription.getAToZDirection())
+ .setZToADirection(pathDescription.getZToADirection());
+ }
+ return builder.build();
+ }
+
+ /**
+ * Send renderer notification.
+ * @param notification Notification
+ */
+ private void send(Notification notification) {
+ try {
+ LOG.info("Sending notification {}", notification);
+ notificationPublishService.putNotification(notification);
+ } catch (InterruptedException e) {
+ LOG.info("notification offer rejected: ", e);
+ Thread.currentThread().interrupt();
+ }
+ }
+
}
<argument ref="otnDeviceRenderer" />
</bean>
- <bean id="networkModelWavelengthService"
- class="org.opendaylight.transportpce.renderer.NetworkModelWavelengthServiceImpl">
- <argument ref="dataBroker" />
- </bean>
-
<bean id="rendererServiceOperations" class="org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperationsImpl" >
<argument ref="deviceRenderer" />
<argument ref="otnDeviceRenderer"/>
<argument ref="olmService" />
<argument ref="dataBroker" />
- <argument ref="networkModelWavelengthService" />
<argument ref="notificationPublishService" />
</bean>
interface="org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService" />
<service ref="rendererServiceOperations"
interface="org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations" />
- <service ref="networkModelWavelengthService"
- interface="org.opendaylight.transportpce.renderer.NetworkModelWavelengthService" />
<service ref="otnDeviceRenderer"
interface="org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService"/>
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
-import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub;
import org.opendaylight.transportpce.renderer.utils.CreateOtsOmsDataUtils;
import org.opendaylight.transportpce.renderer.utils.MountPointUtils;
import org.opendaylight.transportpce.test.AbstractTest;
+import org.opendaylight.transportpce.test.stub.MountPointServiceStub;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.CreateOtsOmsInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.CreateOtsOmsOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.Network;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthServiceImpl;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
-import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub;
-import org.opendaylight.transportpce.renderer.stub.MountPointStub;
import org.opendaylight.transportpce.renderer.stub.OlmServiceStub;
import org.opendaylight.transportpce.renderer.utils.NotificationPublishServiceMock;
import org.opendaylight.transportpce.renderer.utils.ServiceDeleteDataUtils;
import org.opendaylight.transportpce.renderer.utils.TransactionUtils;
import org.opendaylight.transportpce.test.AbstractTest;
+import org.opendaylight.transportpce.test.stub.MountPointServiceStub;
+import org.opendaylight.transportpce.test.stub.MountPointStub;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.TransportpceOlmService;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceDeleteInputBuilder;
private DeviceRendererService deviceRenderer;
private PortMapping portMapping;
private CrossConnect crossConnect;
- private NetworkModelWavelengthService networkModelWavelengthService;
private TransportpceOlmService olmService;
private MappingUtils mappingUtils;
private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121;
this.olmService = Mockito.spy(this.olmService);
ListeningExecutorService executor =
MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUMBER_OF_THREADS));
- this.networkModelWavelengthService = new NetworkModelWavelengthServiceImpl(getDataBroker());
NotificationPublishService notificationPublishService = new NotificationPublishServiceMock();
this.rendererServiceOperations = new RendererServiceOperationsImpl(this.deviceRenderer,
- this.otnDeviceRendererService, olmService, getDataBroker(), this.networkModelWavelengthService,
- notificationPublishService);
+ this.otnDeviceRendererService, olmService, getDataBroker(), notificationPublishService);
}
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthServiceImpl;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
-import org.opendaylight.transportpce.renderer.stub.MountPointServiceStub;
-import org.opendaylight.transportpce.renderer.stub.MountPointStub;
import org.opendaylight.transportpce.renderer.stub.OlmServiceStub;
import org.opendaylight.transportpce.renderer.utils.MountPointUtils;
import org.opendaylight.transportpce.renderer.utils.NotificationPublishServiceMock;
import org.opendaylight.transportpce.renderer.utils.ServiceDataUtils;
import org.opendaylight.transportpce.test.AbstractTest;
+import org.opendaylight.transportpce.test.stub.MountPointServiceStub;
+import org.opendaylight.transportpce.test.stub.MountPointStub;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.ServicePathOutputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInputBuilder;
private OpenRoadmInterfaceFactory openRoadmInterfaceFactory;
private CrossConnect crossConnect;
private TransportpceOlmService olmService;
- private NetworkModelWavelengthService networkModelWavelengthService;
private MappingUtils mappingUtils;
private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121;
private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221;
public void setUp() throws OpenRoadmInterfaceException {
setMountPoint(new MountPointStub(getDataBroker()));
this.olmService = new OlmServiceStub();
- this.networkModelWavelengthService = new NetworkModelWavelengthServiceImpl(getDataBroker());
this.deviceRenderer = new DeviceRendererServiceImpl(this.getDataBroker(), this.deviceTransactionManager,
openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect, portMapping, null);
this.otnDeviceRendererService = new OtnDeviceRendererServiceImpl(openRoadmInterfaceFactory, this.crossConnect,
this.olmService = Mockito.spy(this.olmService);
this.deviceRenderer = Mockito.spy(this.deviceRenderer);
this.rendererServiceOperations = new RendererServiceOperationsImpl(this.deviceRenderer,
- this.otnDeviceRendererService, this.olmService, getDataBroker(), this.networkModelWavelengthService,
- notificationPublishService);
+ this.otnDeviceRendererService, this.olmService, getDataBroker(), notificationPublishService);
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
-import org.opendaylight.transportpce.renderer.stub.MountPointStub;
+import org.opendaylight.transportpce.test.stub.MountPointStub;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.Network;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.Nodes;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.NodesKey;
import org.opendaylight.transportpce.common.OperationResult;
import org.opendaylight.transportpce.common.ResponseCodes;
import org.opendaylight.transportpce.pce.service.PathComputationService;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.opendaylight.transportpce.servicehandler.DowngradeConstraints;
import org.opendaylight.transportpce.servicehandler.ModelMappingUtils;
public ServicehandlerImpl(DataBroker databroker, PathComputationService pathComputationService,
RendererServiceOperations rendererServiceOperations, NotificationPublishService notificationPublishService,
- PceListenerImpl pceListenerImpl, RendererListenerImpl rendererListenerImpl,
- NetworkModelWavelengthService networkModelWavelengthService) {
+ PceListenerImpl pceListenerImpl, RendererListenerImpl rendererListenerImpl) {
this.db = databroker;
this.serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(this.db);
this.serviceDataStoreOperations.initialize();
import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.pce.service.PathComputationService;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.opendaylight.transportpce.servicehandler.listeners.PceListenerImpl;
import org.opendaylight.transportpce.servicehandler.listeners.RendererListenerImpl;
private final DataBroker dataBroker;
private final RpcProviderService rpcService;
private final NotificationService notificationService;
- private final NetworkModelWavelengthService networkModelWavelengthService;
private final NotificationPublishService notificationPublishService;
private ListenerRegistration<TransportpcePceListener> pcelistenerRegistration;
private ListenerRegistration<TransportpceRendererListener> rendererlistenerRegistration;
public ServicehandlerProvider(final DataBroker dataBroker, RpcProviderService rpcProviderService,
NotificationService notificationService, PathComputationService pathComputationService,
RendererServiceOperations rendererServiceOperations,
- NetworkModelWavelengthService networkModelWavelengthService,
NotificationPublishService notificationPublishService) {
this.dataBroker = dataBroker;
this.rpcService = rpcProviderService;
this.notificationService = notificationService;
this.pathComputationService = pathComputationService;
this.rendererServiceOperations = rendererServiceOperations;
- this.networkModelWavelengthService = networkModelWavelengthService;
this.notificationPublishService = notificationPublishService;
}
pcelistenerRegistration = notificationService.registerNotificationListener(pceListenerImpl);
rendererlistenerRegistration = notificationService.registerNotificationListener(rendererListenerImpl);
final ServicehandlerImpl servicehandler = new ServicehandlerImpl(dataBroker, pathComputationService,
- rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl,
- networkModelWavelengthService);
+ rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl);
rpcRegistration =
rpcService.registerRpcImplementation(OrgOpenroadmServiceService.class, servicehandler);
}
import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.RendererRpcResultSp;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.TransportpceRendererListener;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.ServiceRpcResultSh;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.ServiceRpcResultShBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.ServiceNotificationTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev181130.State;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev181130.AdminStates;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.RpcStatusEx;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private ServiceInput input;
private PCEServiceWrapper pceServiceWrapper;
private Boolean tempService;
+ private NotificationPublishService notificationPublishService;
public RendererListenerImpl(PathComputationService pathComputationService,
NotificationPublishService notificationPublishService) {
this.pceServiceWrapper = new PCEServiceWrapper(pathComputationService, notificationPublishService);
setServiceInput(null);
setTempService(false);
+ this.notificationPublishService = notificationPublishService;
}
@Override
return;
}
serviceRpcResultSp = notification;
- String serviceName = serviceRpcResultSp.getServiceName();
int notifType = serviceRpcResultSp.getNotificationType().getIntValue();
LOG.info("Renderer '{}' Notification received : {}", serviceRpcResultSp.getNotificationType().getName(),
notification);
switch (notifType) {
/* service-implementation-request. */
case 3 :
- onServiceImplementationResult(serviceName);
+ onServiceImplementationResult(notification);
break;
/* service-delete. */
case 4 :
- onServiceDeleteResult(serviceName);
+ onServiceDeleteResult(notification);
break;
default:
break;
/**
* Process service delete result for serviceName.
- * @param serviceName String
+ * @param notification RendererRpcResultSp
*/
- private void onServiceDeleteResult(String serviceName) {
- if (serviceRpcResultSp.getStatus() == RpcStatusEx.Failed) {
- LOG.error("Renderer service delete failed !");
- return;
- } else if (serviceRpcResultSp.getStatus() == RpcStatusEx.Pending) {
- LOG.warn("Renderer service delete returned a Penging RpcStatusEx code!");
- return;
- } else if (serviceRpcResultSp.getStatus() != RpcStatusEx.Successful) {
- LOG.error("Renderer service delete returned an unknown RpcStatusEx code!");
- return;
+ private void onServiceDeleteResult(RendererRpcResultSp notification) {
+ switch (serviceRpcResultSp.getStatus()) {
+ case Successful:
+ LOG.info("Service '{}' deleted !", notification.getServiceName());
+ break;
+ case Failed:
+ LOG.error("Renderer service delete failed !");
+ return;
+ case Pending:
+ LOG.warn("Renderer service delete returned a Penging RpcStatusEx code!");
+ return;
+ default:
+ LOG.error("Renderer service delete returned an unknown RpcStatusEx code!");
+ return;
}
- LOG.info("Service '{}' deleted !", serviceName);
if (this.input == null) {
LOG.error("ServiceInput parameter is null !");
return;
LOG.info("sending PCE cancel resource reserve for '{}'", this.input.getServiceName());
this.pceServiceWrapper.cancelPCEResource(this.input.getServiceName(),
ServiceNotificationTypes.ServiceDeleteResult);
+ sendServiceHandlerNotification(notification, ServiceNotificationTypes.ServiceDeleteResult);
}
/**
* Process service implementation result for serviceName.
- * @param serviceName String
- * @param serviceName String
+ * @param notification RendererRpcResultSp
*/
- private void onServiceImplementationResult(String serviceName) {
- if (serviceRpcResultSp.getStatus() == RpcStatusEx.Successful) {
- onSuccededServiceImplementation();
- } else if (serviceRpcResultSp.getStatus() == RpcStatusEx.Failed) {
- onFailedServiceImplementation(serviceName);
- } else if (serviceRpcResultSp.getStatus() == RpcStatusEx.Pending) {
- LOG.warn("Service Implementation still pending according to RpcStatusEx");
- } else {
- LOG.warn("Service Implementation has an unknown RpcStatusEx code");
+ private void onServiceImplementationResult(RendererRpcResultSp notification) {
+ switch (serviceRpcResultSp.getStatus()) {
+ case Successful:
+ onSuccededServiceImplementation(notification);
+ break;
+ case Failed:
+ onFailedServiceImplementation(notification.getServiceName());
+ break;
+ case Pending:
+ LOG.warn("Service Implementation still pending according to RpcStatusEx");
+ break;
+ default:
+ LOG.warn("Service Implementation has an unknown RpcStatusEx code");
+ break;
}
-
}
/**
* Process succeeded service implementation for service.
+ * @param notification RendererRpcResultSp
*/
- private void onSuccededServiceImplementation() {
+ private void onSuccededServiceImplementation(RendererRpcResultSp notification) {
LOG.info("Service implemented !");
if (serviceDataStoreOperations == null) {
LOG.debug("serviceDataStoreOperations is null");
AdminStates.InService);
if (!operationResult.isSuccess()) {
LOG.warn("Service status not updated in datastore !");
+ } else {
+ sendServiceHandlerNotification(notification, ServiceNotificationTypes.ServiceCreateResult);
}
}
}
+ /**
+ * Create and send service handler notification.
+ * @param notification RendererRpcResultSp
+ * @param type ServiceNotificationTypes
+ */
+ private void sendServiceHandlerNotification(RendererRpcResultSp notification, ServiceNotificationTypes type) {
+ try {
+ ServiceRpcResultSh serviceHandlerNotification = new ServiceRpcResultShBuilder()
+ .setAToZDirection(notification.getAToZDirection())
+ .setZToADirection(notification.getZToADirection())
+ .setServiceName(notification.getServiceName())
+ .setStatus(notification.getStatus())
+ .setStatusMessage(notification.getStatusMessage())
+ .setNotificationType(type)
+ .build();
+ LOG.debug("Service update in datastore OK, sending notification {}", serviceHandlerNotification);
+ notificationPublishService.putNotification(
+ serviceHandlerNotification);
+ } catch (InterruptedException e) {
+ LOG.warn("Something went wrong while sending notification for sevice {}",
+ serviceRpcResultSp.getServiceName(), e);
+ Thread.currentThread().interrupt();
+ }
+ }
+
/**
* Process failed service implementation for serviceName.
* @param serviceName String
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.pce.service.PathComputationService;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.opendaylight.transportpce.servicehandler.impl.ServicehandlerImpl;
import org.opendaylight.transportpce.servicehandler.listeners.PceListenerImpl;
public ServiceHandlerOperationsImpl(DataBroker databroker, PathComputationService pathComputationService,
RendererServiceOperations rendererServiceOperations, NotificationPublishService notificationPublishService,
- PceListenerImpl pceListenerImpl, RendererListenerImpl rendererListenerImpl,
- NetworkModelWavelengthService networkModelWavelengthService) {
+ PceListenerImpl pceListenerImpl, RendererListenerImpl rendererListenerImpl) {
this.serviceHandler = new ServicehandlerImpl(databroker, pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl,networkModelWavelengthService);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
}
@Override
<reference id="rendererServiceOperations"
interface="org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations" />
- <reference id="networkModelWavelengthService"
- interface="org.opendaylight.transportpce.renderer.NetworkModelWavelengthService" />
-
<bean id="serviceDatastoreOperation" class="org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperationsImpl">
<argument ref="dataBroker"/>
</bean>
<argument ref="pathComputationService" />
<argument ref="notificationPublishService" />
<argument ref="rendererServiceOperations" />
- <argument ref="networkModelWavelengthService" />
<argument ref="pceListener" />
<argument ref="rendererListener" />
</bean>
<argument ref="notificationPublishService" />
<argument ref="pathComputationService" />
<argument ref="rendererServiceOperations" />
- <argument ref="networkModelWavelengthService" />
</bean>
<service ref="serviceHandlerImpl"
public void createServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceCreateOutput>> result =
servicehandlerImpl.serviceCreate(new ServiceCreateInputBuilder().build());
result.addListener(new Runnable() {
Mockito.when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any()));
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceCreateOutput>> result = servicehandlerImpl.serviceCreate(input);
result.addListener(new Runnable() {
@Override
public void deleteServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceDeleteOutput>> result =
servicehandlerImpl.serviceDelete(new ServiceDeleteInputBuilder()
.setServiceDeleteReqInfo(new ServiceDeleteReqInfoBuilder().setServiceName("").build()).build());
ServiceDeleteInput input = ServiceDataUtils.buildServiceDeleteInput();
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceDeleteOutput>> result = servicehandlerImpl.serviceDelete(input);
result.addListener(new Runnable() {
@Override
Mockito.when(rendererServiceOperations.serviceDelete(any(), any())).thenReturn(Futures.immediateFuture(any()));
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(dataBroker, pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ServiceDataStoreOperationsImpl serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(dataBroker);
ServiceCreateInput createInput = ServiceDataUtils.buildServiceCreateInput();
serviceDataStoreOperations.createService(createInput);
public void serviceFeasibilityCheckShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceFeasibilityCheckOutput>> result =
servicehandlerImpl.serviceFeasibilityCheck(new ServiceFeasibilityCheckInputBuilder().build());
result.addListener(new Runnable() {
Mockito.when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any()));
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceFeasibilityCheckOutput>> result =
servicehandlerImpl.serviceFeasibilityCheck(input);
result.addListener(new Runnable() {
public void serviceReconfigureShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceReconfigureOutput>> result =
servicehandlerImpl.serviceReconfigure(new ServiceReconfigureInputBuilder().setServiceName("").build());
result.addListener(new Runnable() {
//action -> service reconfigure
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceReconfigureOutput>> result = servicehandlerImpl.serviceReconfigure(input);
result.addListener(new Runnable() {
//create service to reconfigure
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(dataBroker, pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ServiceDataStoreOperationsImpl serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(dataBroker);
ServiceCreateInput createInput = ServiceDataUtils.buildServiceCreateInput();
serviceDataStoreOperations.createService(createInput);
public void serviceReRestorationShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceRestorationOutput>> result =
servicehandlerImpl.serviceRestoration(new ServiceRestorationInputBuilder().setServiceName("").build());
result.addListener(new Runnable() {
//action -> service restore
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceRestorationOutput>> result = servicehandlerImpl.serviceRestoration(input);
result.addListener(new Runnable() {
//create service to restore
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(dataBroker, pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ServiceDataStoreOperationsImpl serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(dataBroker);
ServiceCreateInput createInput = ServiceDataUtils.buildServiceCreateInput();
serviceDataStoreOperations.createService(createInput);
public void serviceRerouteShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceRerouteOutput>> result =
servicehandlerImpl.serviceReroute(new ServiceRerouteInputBuilder().setServiceName("").build());
result.addListener(new Runnable() {
//action -> service reconfigure
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<ServiceRerouteOutput>> result = servicehandlerImpl.serviceReroute(input);
result.addListener(new Runnable() {
//create service to be rerouted later
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(dataBroker, pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ServiceDataStoreOperationsImpl serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(dataBroker);
ServiceCreateInput createInput = ServiceDataUtils.buildServiceCreateInput();
serviceDataStoreOperations.createService(createInput);
public void tempServiceDeleteShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<TempServiceDeleteOutput>> result =
servicehandlerImpl.tempServiceDelete(new TempServiceDeleteInputBuilder()
.setCommonId("").build());
TempServiceDeleteInput input = ServiceDataUtils.buildTempServiceDeleteInput();
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<TempServiceDeleteOutput>> result = servicehandlerImpl.tempServiceDelete(input);
result.addListener(new Runnable() {
@Override
//create temp service to delete in the temp delete action
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(dataBroker, pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ServiceDataStoreOperationsImpl serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(dataBroker);
TempServiceCreateInput createInput = ServiceDataUtils.buildTempServiceCreateInput();
serviceDataStoreOperations.createTempService(createInput);
public void tempServiceCreateShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException {
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<TempServiceCreateOutput>> result =
servicehandlerImpl.tempServiceCreate(new TempServiceCreateInputBuilder().build());
result.addListener(new Runnable() {
ServicehandlerImpl servicehandlerImpl =
new ServicehandlerImpl(getNewDataBroker(), pathComputationService, rendererServiceOperations,
- notificationPublishService, pceListenerImpl, rendererListenerImpl, null);
+ notificationPublishService, pceListenerImpl, rendererListenerImpl);
ListenableFuture<RpcResult<TempServiceCreateOutput>> result = servicehandlerImpl.tempServiceCreate(input);
result.addListener(new Runnable() {
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.pce.service.PathComputationService;
-import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
import org.opendaylight.transportpce.test.AbstractTest;
@Mock
RpcProviderService rpcProviderRegistry;
- @Mock
- NetworkModelWavelengthService networkModelWavelengthService;
-
@Before
public void init() {
MockitoAnnotations.initMocks(this);
ServicehandlerProvider provider = new ServicehandlerProvider(
getDataBroker(), rpcProviderRegistry,
getNotificationService() , pathComputationService,
- rendererServiceOperations, networkModelWavelengthService,
- notificationPublishService);
+ rendererServiceOperations, notificationPublishService);
provider.init();
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.transportpce.renderer.stub;
+package org.opendaylight.transportpce.test.stub;
import java.util.Optional;
import org.opendaylight.mdsal.binding.api.MountPoint;
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.transportpce.renderer.stub;
+package org.opendaylight.transportpce.test.stub;
import java.util.Optional;
import javax.annotation.Nonnull;
Code Review / transportpce.git / commitdiff