From e4106d346bc8313726b154af4d30e3cc875b4706 Mon Sep 17 00:00:00 2001 From: Javier Errea Date: Wed, 3 Feb 2021 13:37:20 +0100 Subject: [PATCH] Initial OR-TAPI mapping: Services - OR service -> TAPI connectivity service mapping - ConnectivityService utils class - TAPI context extended to update Connectivity context - New service: ServiceDataStoreOperations in ServiceHandler blueprint - 2 new operations in ServiceDataStoreOperations - TAPI blueprint uses ServiceDataStoreOperations service - Lighty modifications to create TAPI provider correctly - Added removal of CEPs in getTopologyDetailsOutput JIRA: TRNSPRTPCE-425 Change-Id: Ib146a85124359b31fc3c46f09b433a0c9daabfb3 Signed-off-by: errea --- .../tpce/module/TransportPCEImpl.java | 7 +- .../service/ServiceDataStoreOperations.java | 11 + .../ServiceDataStoreOperationsImpl.java | 22 +- .../blueprint/servicehandler-blueprint.xml | 3 + .../tapi/connectivity/ConnectivityUtils.java | 1124 +++++++++++++++++ .../connectivity/TapiConnectivityImpl.java | 3 +- .../transportpce/tapi/impl/TapiProvider.java | 15 +- .../tapi/topology/TopologyUtils.java | 52 +- .../transportpce/tapi/utils/MappingUtils.java | 13 +- .../transportpce/tapi/utils/TapiContext.java | 82 ++ .../tapi/utils/TapiInitialORMapping.java | 37 +- .../transportpce/tapi/utils/TapiUtils.java | 158 --- .../OSGI-INF/blueprint/tapi-blueprint.xml | 4 + .../tapi/topology/TapiTopologyImplTest.java | 11 +- 14 files changed, 1362 insertions(+), 180 deletions(-) create mode 100644 tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/ConnectivityUtils.java delete mode 100644 tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiUtils.java diff --git a/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java b/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java index 1611a08a5..05992243d 100644 --- a/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java +++ b/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java @@ -189,7 +189,7 @@ public class TransportPCEImpl extends AbstractLightyModule implements TransportP serviceDataStoreOperations, pceListenerImpl, rendererListenerImpl, networkModelListenerImpl, servicehandler); - tapiProvider = initTapi(lightyServices, servicehandler, networkTransaction); + tapiProvider = initTapi(lightyServices, servicehandler, networkTransaction, serviceDataStoreOperations); if(activateNbiNotification) { LOG.info("Creating nbi-notifications beans ..."); nbiNotificationsProvider = new NbiNotificationsProvider( @@ -250,9 +250,10 @@ public class TransportPCEImpl extends AbstractLightyModule implements TransportP * @return TapiProvider instance */ private TapiProvider initTapi(LightyServices lightyServices, OrgOpenroadmServiceService servicehandler, - NetworkTransactionService networkTransaction) { + NetworkTransactionService networkTransaction, + ServiceDataStoreOperations serviceDataStoreOperations) { return new TapiProvider(lightyServices.getBindingDataBroker(), lightyServices.getRpcProviderService(), - servicehandler, new TapiListener(), networkTransaction); + servicehandler, serviceDataStoreOperations, new TapiListener(), networkTransaction); } /** diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/service/ServiceDataStoreOperations.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/service/ServiceDataStoreOperations.java index d84cf2345..f388ebe3c 100644 --- a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/service/ServiceDataStoreOperations.java +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/service/ServiceDataStoreOperations.java @@ -14,10 +14,12 @@ import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev20 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State; import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceCreateInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceList; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.TempServiceCreateInput; 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.service.types.rev200128.service.path.PathDescription; import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev171017.ServicePathList; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev171017.service.path.list.ServicePaths; /** * OpenROADM Service operations API providing basic operations on services. @@ -38,6 +40,13 @@ public interface ServiceDataStoreOperations { */ Optional getService(String serviceName); + /** + * get all OR services. + * + * @return Optional of Services + */ + Optional getServices(); + /** * get temp service by common-id. * @@ -97,6 +106,8 @@ public interface ServiceDataStoreOperations { */ OperationResult createService(ServiceCreateInput serviceCreateInput); + Optional getServicePath(String serviceName); + /** * create new servicePath entry. * diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/service/ServiceDataStoreOperationsImpl.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/service/ServiceDataStoreOperationsImpl.java index c9a499083..b971605f7 100644 --- a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/service/ServiceDataStoreOperationsImpl.java +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/service/ServiceDataStoreOperationsImpl.java @@ -127,8 +127,23 @@ public class ServiceDataStoreOperationsImpl implements ServiceDataStoreOperation } @Override - public Optional getTempService(String serviceName) { + public Optional getServices() { + try { + ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction(); + InstanceIdentifier iid = + InstanceIdentifier.create(ServiceList.class); + Future> future = + readTx.read(LogicalDatastoreType.OPERATIONAL, iid); + return future.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS); + } catch (InterruptedException | ExecutionException | TimeoutException e) { + LOG.warn("Reading services failed:", e); + } + return Optional.empty(); + } + + @Override + public Optional + getTempService(String serviceName) { try { ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction(); InstanceIdentifier getServicePath(String serviceName) { + @Override + public Optional getServicePath(String serviceName) { LOG.debug("Retrieving service path of service {}", serviceName); try { ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction(); diff --git a/servicehandler/src/main/resources/OSGI-INF/blueprint/servicehandler-blueprint.xml b/servicehandler/src/main/resources/OSGI-INF/blueprint/servicehandler-blueprint.xml index 5813d31ab..61944e631 100644 --- a/servicehandler/src/main/resources/OSGI-INF/blueprint/servicehandler-blueprint.xml +++ b/servicehandler/src/main/resources/OSGI-INF/blueprint/servicehandler-blueprint.xml @@ -80,4 +80,7 @@ Author: Martial Coulibaly on behalf of Orange + + diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/ConnectivityUtils.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/ConnectivityUtils.java new file mode 100644 index 000000000..df390295c --- /dev/null +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/ConnectivityUtils.java @@ -0,0 +1,1124 @@ +/* + * Copyright © 2018 Orange & 2021 Nokia, 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.tapi.connectivity; + +import java.nio.charset.Charset; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.UUID; +import java.util.stream.Collectors; +import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations; +import org.opendaylight.transportpce.tapi.topology.TopologyUtils; +import org.opendaylight.transportpce.tapi.utils.GenericServiceEndpoint; +import org.opendaylight.transportpce.tapi.utils.ServiceEndpointType; +import org.opendaylight.transportpce.tapi.utils.TapiContext; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.equipment.types.rev181130.OpticTypes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.node.types.rev181130.NodeIdType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.ConnectionType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.RpcActions; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.Service; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.sdnc.request.header.SdncRequestHeaderBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.endpoint.RxDirectionBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.endpoint.TxDirectionBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.lgx.LgxBuilder; +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.openroadm.service.rev190531.ServiceCreateInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceCreateInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceAEnd; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceAEndBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceZEnd; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceZEndBuilder; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201210.PathDescription; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201210.path.description.atoz.direction.AToZ; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201210.path.description.atoz.direction.AToZKey; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201210.path.description.ztoa.direction.ZToA; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201210.path.description.ztoa.direction.ZToAKey; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201210.pce.resource.resource.resource.Node; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201210.pce.resource.resource.resource.TerminationPoint; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev171017.service.path.list.ServicePaths; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.AdministrativeState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.CapacityUnit; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.ForwardingDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LayerProtocolName; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LifecycleState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.OperationalState; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortDirection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortRole; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.capacity.BandwidthProfileBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.capacity.TotalSizeBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.Name; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.tapi.context.ServiceInterfacePoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.tapi.context.ServiceInterfacePointKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.ProtectionRole; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPointKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connection.end.point.ClientNodeEdgePoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connection.end.point.ClientNodeEdgePointBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityService; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityServiceBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.Connection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.ConnectionBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.ConnectionKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.EndPoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.EndPointBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.EndPointKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.end.point.CapacityBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.end.point.ServiceInterfacePointBuilder; +import org.opendaylight.yangtools.yang.common.Uint32; +import org.opendaylight.yangtools.yang.common.Uint64; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class ConnectivityUtils { + + private static final String LGX_PORT_NAME = "Some lgx-port-name"; + private static final String PORT_TYPE = "some port type"; + private static final String LGX_DEVICE_NAME = "Some lgx-device-name"; + private static final String PORT_RACK_VALUE = "000000.00"; + private static final String DSR = "DSR"; + private static final String ODU = "ODU"; + private static final String E_ODU = "eODU"; + private static final String I_ODU = "iODU"; + private static final String OTSI = "OTSi"; + private static final String E_OTSI = "eOTSi"; + private static final String I_OTSI = "iOTSi"; + private static final String PHTNC_MEDIA = "PHOTONIC_MEDIA"; + private static final String MC = "MEDIA_CHANNEL"; + private static final String OTSI_MC = "OTSi_MEDIA_CHANNEL"; + private static final String TP = "TerminationPoint"; + private static final String NODE = "Node"; + private static final Logger LOG = LoggerFactory.getLogger(ConnectivityUtils.class); + + private final ServiceDataStoreOperations serviceDataStoreOperations; + private final TapiContext tapiContext; + private Map sipMap; + private final Map + connectionFullMap; // this variable is for complete connection objects + + // TODO -> handle cases for which node id is ROADM-A1 and not ROADMA01 or XPDR-A1 and not XPDRA01 + public ConnectivityUtils(ServiceDataStoreOperations serviceDataStoreOperations, + Map sipMap, TapiContext tapiContext) { + this.serviceDataStoreOperations = serviceDataStoreOperations; + this.tapiContext = tapiContext; + this.sipMap = sipMap; + this.connectionFullMap = new HashMap<>(); + } + + public static ServiceCreateInput buildServiceCreateInput(GenericServiceEndpoint sepA, GenericServiceEndpoint sepZ) { + ServiceAEnd serviceAEnd = getServiceAEnd(sepA, sepZ); + ServiceZEnd serviceZEnd = getServiceZEnd(sepA, sepZ); + if (serviceAEnd == null || serviceZEnd == null) { + LOG.warn("One of the endpoints could not be identified"); + return null; + } + return new ServiceCreateInputBuilder() + .setCommonId("commonId") + .setConnectionType(ConnectionType.Service) + .setCustomer("Customer") + .setServiceName("service test") + .setServiceAEnd(serviceAEnd) + .setServiceZEnd(serviceZEnd) + .setSdncRequestHeader(new SdncRequestHeaderBuilder().setRequestId("request-1") + .setRpcAction(RpcActions.ServiceCreate).setNotificationUrl("notification url").setRequestSystemId( + "appname") + .build()) + .build(); + } + + public static ServiceAEnd buildServiceAEnd(String nodeid, String clli, String txPortDeviceName, + String txPortName, String rxPortDeviceName, String rxPortName) { + return new ServiceAEndBuilder() + .setClli(clli) + .setNodeId(new NodeIdType(nodeid)) + .setOpticType(OpticTypes.Gray) + .setServiceFormat(ServiceFormat.Ethernet) + .setServiceRate(Uint32.valueOf(100)) + .setTxDirection(new TxDirectionBuilder() + .setPort(new PortBuilder() + .setPortDeviceName(txPortDeviceName) + .setPortName(txPortName) + .setPortRack(PORT_RACK_VALUE) + .setPortShelf("00") + .setPortType(PORT_TYPE) + .build()) + .setLgx(new LgxBuilder() + .setLgxDeviceName(LGX_DEVICE_NAME) + .setLgxPortName(LGX_PORT_NAME) + .setLgxPortRack(PORT_RACK_VALUE) + .setLgxPortShelf("00") + .build()) + .build()) + .setRxDirection(new RxDirectionBuilder() + .setPort(new PortBuilder() + .setPortDeviceName(rxPortDeviceName) + .setPortName(rxPortName) + .setPortRack(PORT_RACK_VALUE) + .setPortShelf("00") + .setPortType(PORT_TYPE) + .build()) + .setLgx(new LgxBuilder() + .setLgxDeviceName(LGX_DEVICE_NAME) + .setLgxPortName(LGX_PORT_NAME) + .setLgxPortRack(PORT_RACK_VALUE) + .setLgxPortShelf("00") + .build()) + .build()) + .build(); + } + + public static ServiceZEnd buildServiceZEnd(String nodeid, String clli, String txPortDeviceName, + String txPortName, String rxPortDeviceName, String rxPortName) { + return new ServiceZEndBuilder().setClli(clli).setNodeId(new NodeIdType(nodeid)) + .setOpticType(OpticTypes.Gray) + .setServiceFormat(ServiceFormat.Ethernet) + .setServiceRate(Uint32.valueOf(100)) + .setTxDirection(new TxDirectionBuilder() + .setPort(new PortBuilder() + .setPortDeviceName(txPortDeviceName) + .setPortName(txPortName) + .setPortRack(PORT_RACK_VALUE) + .setPortShelf("00") + .setPortType(PORT_TYPE) + .build()) + .setLgx(new LgxBuilder() + .setLgxDeviceName(LGX_DEVICE_NAME) + .setLgxPortName(LGX_PORT_NAME) + .setLgxPortRack(PORT_RACK_VALUE) + .setLgxPortShelf("00") + .build()) + .build()) + .setRxDirection(new RxDirectionBuilder() + .setPort(new PortBuilder() + .setPortDeviceName(rxPortDeviceName) + .setPortName(rxPortName) + .setPortRack(PORT_RACK_VALUE) + .setPortShelf("00") + .setPortType(PORT_TYPE) + .build()) + .setLgx(new LgxBuilder() + .setLgxDeviceName(LGX_DEVICE_NAME) + .setLgxPortName(LGX_PORT_NAME) + .setLgxPortRack(PORT_RACK_VALUE) + .setLgxPortShelf("00") + .build()) + .build()) + .build(); + } + + private static ServiceAEnd getServiceAEnd(GenericServiceEndpoint sepA, GenericServiceEndpoint sepZ) { + if (sepA.getType().equals(ServiceEndpointType.SERVICEAEND)) { + return new ServiceAEndBuilder(sepA.getValue()).build(); + } else if (sepZ.getType().equals(ServiceEndpointType.SERVICEAEND)) { + return new ServiceAEndBuilder(sepZ.getValue()).build(); + } else { + return null; + } + } + + private static ServiceZEnd getServiceZEnd(GenericServiceEndpoint sepA, GenericServiceEndpoint sepZ) { + if (sepA.getType().equals(ServiceEndpointType.SERVICEZEND)) { + return new ServiceZEndBuilder(sepA.getValue()).build(); + } else if (sepZ.getType().equals(ServiceEndpointType.SERVICEZEND)) { + return new ServiceZEndBuilder(sepZ.getValue()).build(); + } else { + return null; + } + } + + public void setSipMap(Map sips) { + this.sipMap = sips; + } + + public ConnectivityService mapORServiceToTapiConnectivity(Service service) { + // Get service path with the description in OR based models. + LOG.info("Service = {}", service); + Optional optServicePaths = + this.serviceDataStoreOperations.getServicePath(service.getServiceName()); + if (!optServicePaths.isPresent()) { + LOG.error("No service path found for service {}", service.getServiceName()); + return null; + } + ServicePaths servicePaths = optServicePaths.get(); + PathDescription pathDescription = servicePaths.getPathDescription(); + LOG.info("Path description of service = {}", pathDescription); + org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.ServiceAEnd serviceAEnd + = service.getServiceAEnd(); + // Endpoint creation + EndPoint endPoint1 = mapServiceAEndPoint(serviceAEnd, pathDescription); + org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.ServiceZEnd serviceZEnd + = service.getServiceZEnd(); + EndPoint endPoint2 = mapServiceZEndPoint(serviceZEnd, pathDescription); + Map endPointMap = new HashMap<>(); + endPointMap.put(endPoint1.key(), endPoint1); + endPointMap.put(endPoint2.key(), endPoint2); + LOG.info("EndPoints of connectivity services = {}", endPointMap); + // Services Names + Name name = new NameBuilder().setValueName("Connectivity Service Name").setValue(service.getServiceName()) + .build(); + // Connection creation + Map connMap = + createConnectionsFromService(serviceAEnd, serviceZEnd, pathDescription); + // TODO: full connectivity service?? With constraints and the rest of fields... + return new ConnectivityServiceBuilder() + .setAdministrativeState(AdministrativeState.UNLOCKED) + .setOperationalState(OperationalState.ENABLED) + .setLifecycleState(LifecycleState.INSTALLED) + .setUuid(new Uuid(UUID.nameUUIDFromBytes(service.getServiceName().getBytes(Charset.forName("UTF-8"))) + .toString())) + .setConnectivityDirection(ForwardingDirection.BIDIRECTIONAL) + .setName(Map.of(name.key(), name)) + .setConnection(connMap) + .setEndPoint(endPointMap) + .build(); + } + + private Map createConnectionsFromService( + org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.ServiceAEnd + serviceAEnd, + org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.ServiceZEnd + serviceZEnd, + PathDescription pathDescription) { + Map connectionServMap = new HashMap<>(); + // build lists with ROADM nodes, XPDR/MUX/SWITCH nodes, ROADM DEG TTPs, ROADM SRG TTPs, XPDR CLIENT TTPs + // and XPDR NETWORK TTPs (if any). From the path description. This will help to build the uuid of the CEPs + // and the connections + String resourceType; + List xpdrClientTplist = new ArrayList<>(); + List xpdrNetworkTplist = new ArrayList<>(); + List rdmAddDropTplist = new ArrayList<>(); + List rdmDegTplist = new ArrayList<>(); + List rdmNodelist = new ArrayList<>(); + List xpdrNodelist = new ArrayList<>(); + for (AToZ elem:pathDescription.getAToZDirection().getAToZ().values().stream() + .sorted(Comparator.comparing(AToZ::getId)).collect(Collectors.toList())) { + resourceType = elem.getResource().getResource().implementedInterface().getSimpleName(); + switch (resourceType) { + case TP: + TerminationPoint tp = (TerminationPoint) elem.getResource().getResource(); + String tpID = tp.getTpId(); + String tpNode; + if (tpID.contains("CLIENT")) { + tpNode = tp.getTpNodeId(); + if (!xpdrClientTplist.contains(String.join("+", tpNode, tpID))) { + xpdrClientTplist.add(String.join("+", tpNode, tpID)); + } + } + if (tpID.contains("NETWORK")) { + tpNode = tp.getTpNodeId(); + if (!xpdrNetworkTplist.contains(String.join("+", tpNode, tpID))) { + xpdrNetworkTplist.add(String.join("+", tpNode, tpID)); + } + } + if (tpID.contains("PP")) { + tpNode = getIdBasedOnModelVersion(tp.getTpNodeId()); + LOG.info("ROADM Node of tp = {}", tpNode); + if (!rdmAddDropTplist.contains(String.join("+", tpNode, tpID))) { + rdmAddDropTplist.add(String.join("+", tpNode, tpID)); + } + } + if (tpID.contains("TTP")) { + tpNode = getIdBasedOnModelVersion(tp.getTpNodeId()); + LOG.info("ROADM Node of tp = {}", tpNode); + if (!rdmDegTplist.contains(String.join("+", tpNode, tpID))) { + rdmDegTplist.add(String.join("+", tpNode, tpID)); + } + } + break; + case NODE: + Node node = (Node) elem.getResource().getResource(); + String nodeId = node.getNodeId(); + if (nodeId.contains("XPDR") || nodeId.contains("SPDR") || nodeId.contains("MXPDR")) { + LOG.info("Node id = {}", nodeId); + if (!xpdrNodelist.contains(nodeId)) { + xpdrNodelist.add(nodeId); // should contain only 2 + } + } + if (nodeId.contains("ROADM")) { + nodeId = getIdBasedOnModelVersion(nodeId); + LOG.info("Node id = {}", nodeId); + if (!rdmNodelist.contains(nodeId)) { + rdmNodelist.add(nodeId); + } + } + break; + default: + LOG.warn("Resource is a {}", resourceType); + } + } + LOG.info("ROADM node list = {}", rdmNodelist); + LOG.info("ROADM degree list = {}", rdmDegTplist); + LOG.info("ROADM addrop list = {}", rdmAddDropTplist); + LOG.info("XPDR node list = {}", xpdrNodelist); + LOG.info("XPDR network list = {}", xpdrNetworkTplist); + LOG.info("XPDR client list = {}", xpdrClientTplist); + // TODO -> for 10GB eth and ODU services there are no ROADMs in path description as they use the OTU link, + // but for 100GB eth all is created at once. Check if the roadm list is empty to determine whether we need + // to trigger all the steps or not + String edgeRoadm1 = ""; + String edgeRoadm2 = ""; + if (!rdmNodelist.isEmpty()) { + edgeRoadm1 = rdmNodelist.get(0); + edgeRoadm2 = rdmNodelist.get(rdmNodelist.size() - 1); + LOG.info("edgeRoadm1 = {}", edgeRoadm1); + LOG.info("edgeRoadm2 = {}", edgeRoadm2); + } + // create corresponding CEPs and Connections. Connections should be added to the corresponding context + // CEPs must be included in the topology context as an augmentation for each ONEP!! + ServiceFormat serviceFormat = serviceAEnd.getServiceFormat(); // should be equal to serviceZEnd + // TODO -> better mechanism to map services??? + switch (serviceFormat) { + case OC: + // Identify number of ROADMs + // - XC Connection between MC CEPs mapped from MC NEPs (within a roadm) + // - XC Connection between OTSiMC CEPs mapped from OTSiMC NEPs (within a roadm) + // - Top Connection MC betwwen MC CEPs of different roadms + // - Top Connection OTSiMC betwwen OTSiMC CEPs of extreme roadms + connectionServMap.putAll(createRoadmCepsAndConnections(rdmAddDropTplist, rdmDegTplist, rdmNodelist, + edgeRoadm1, edgeRoadm2)); + break; + case OTU: + // Identify number of ROADMs between XPDRs and check if OC is created + // - XC Connection between MC CEPs mapped from MC NEPs (within a roadm) + // - Top Connection MC betwwen MC CEPs of different roadms + // - XC Connection between OTSiMC CEPs mapped from OTSiMC NEPs (within a roadm) + // - Top Connection OTSiMC betwwen OTSiMC CEPs of different roadms + connectionServMap.putAll(createRoadmCepsAndConnections(rdmAddDropTplist, rdmDegTplist, rdmNodelist, + edgeRoadm1, edgeRoadm2)); + // - XC Connection OTSi betwwen iOTSi y eOTSi of xpdr + // - Top connection OTSi between network ports of xpdrs in the Photonic media layer -> i_OTSi + connectionServMap.putAll(createXpdrCepsAndConnectionsPht(xpdrNetworkTplist, xpdrNodelist)); + break; + case ODU: + // Check if OC and OTU are created + if (!rdmNodelist.isEmpty()) { + connectionServMap.putAll(createRoadmCepsAndConnections(rdmAddDropTplist, rdmDegTplist, rdmNodelist, + edgeRoadm1, edgeRoadm2)); + connectionServMap.putAll(createXpdrCepsAndConnectionsPht(xpdrNetworkTplist, xpdrNodelist)); + } + // - XC Connection OTSi betwwen iODU and eODU of xpdr + // - Top connection in the ODU layer, between xpdr eODU ports (?) + connectionServMap.putAll(createXpdrCepsAndConnectionsOdu(xpdrNetworkTplist, xpdrNodelist)); + break; + case Ethernet: + // Check if OC, OTU and ODU are created + if (!rdmNodelist.isEmpty()) { + connectionServMap.putAll(createRoadmCepsAndConnections(rdmAddDropTplist, rdmDegTplist, rdmNodelist, + edgeRoadm1, edgeRoadm2)); + connectionServMap.putAll(createXpdrCepsAndConnectionsPht(xpdrNetworkTplist, xpdrNodelist)); + connectionServMap.putAll(createXpdrCepsAndConnectionsOdu(xpdrNetworkTplist, xpdrNodelist)); + } + // Top connection in the DSR layer, between client ports of the xpdrs + connectionServMap.putAll(createXpdrCepsAndConnectionsDsr(xpdrClientTplist, xpdrNodelist)); + break; + default: + LOG.error("Service type format not supported"); + } + return connectionServMap; + } + + private Map createXpdrCepsAndConnectionsDsr(List xpdrClientTplist, + List xpdrNodelist) { + Map connServMap = new HashMap<>(); + Map cepMap = new HashMap<>(); + + // Create 1 cep per Xpdr in the CLIENT and a top connection DSR between the CLIENT xpdrs + for (String xpdr:xpdrNodelist) { + LOG.info("Creating ceps and xc for xpdr {}", xpdr); + String spcXpdrClient = xpdrClientTplist.stream().filter(netp -> netp.contains(xpdr)).findFirst().get(); + + ConnectionEndPoint netCep1 = createCepXpdr(spcXpdrClient, DSR, DSR, LayerProtocolName.DSR); + putXpdrCepInTopologyContext(xpdr, spcXpdrClient, DSR, DSR, netCep1); + + cepMap.put(netCep1.key(), netCep1); + } + + // DSR top connection between edge xpdr CLIENT DSR + String spcXpdr1 = xpdrClientTplist.stream().filter(adp -> adp.contains(xpdrNodelist + .get(0))).findFirst().get(); + String spcXpdr2 = xpdrClientTplist.stream().filter(adp -> adp.contains(xpdrNodelist + .get(xpdrNodelist.size() - 1))).findFirst().get(); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + connection = createTopConnection(spcXpdr1, spcXpdr2, cepMap, DSR, LayerProtocolName.DSR); + this.connectionFullMap.put(connection.key(), connection); + + // ODU top connection that will be added to the service object + Connection conn = new ConnectionBuilder().setConnectionUuid(connection.getUuid()).build(); + connServMap.put(conn.key(), conn); + + return connServMap; + } + + private Map createXpdrCepsAndConnectionsOdu(List xpdrNetworkTplist, + List xpdrNodelist) { + Map connServMap = new HashMap<>(); + Map cepMap = new HashMap<>(); + // Create 1 cep per Xpdr in the I_ODU and E_ODU, X connection between iODU and eODU and a top + // connection iODU between the xpdrs + for (String xpdr:xpdrNodelist) { + LOG.info("Creating ceps and xc for xpdr {}", xpdr); + String spcXpdrNetwork = xpdrNetworkTplist.stream().filter(netp -> netp.contains(xpdr)).findFirst().get(); + + ConnectionEndPoint netCep1 = createCepXpdr(spcXpdrNetwork, E_ODU, DSR, LayerProtocolName.ODU); + putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, E_ODU, DSR, netCep1); + ConnectionEndPoint netCep2 = createCepXpdr(spcXpdrNetwork, I_ODU, DSR, LayerProtocolName.ODU); + putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, I_ODU, DSR, netCep2); + + cepMap.put(netCep1.key(), netCep1); + cepMap.put(netCep2.key(), netCep2); + + // Create x connection between I_ODU and E_ODU within xpdr + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + connection = createXCBetweenCeps(netCep1, netCep2, spcXpdrNetwork, spcXpdrNetwork, ODU, + LayerProtocolName.ODU); + this.connectionFullMap.put(connection.key(), connection); + + // Create X connection that will be added to the service object + Connection conn = new ConnectionBuilder().setConnectionUuid(connection.getUuid()).build(); + connServMap.put(conn.key(), conn); + } + + // ODU top connection between edge xpdr e_ODU + String spcXpdr1 = xpdrNetworkTplist.stream().filter(adp -> adp.contains(xpdrNodelist + .get(0))).findFirst().get(); + String spcXpdr2 = xpdrNetworkTplist.stream().filter(adp -> adp.contains(xpdrNodelist + .get(xpdrNodelist.size() - 1))).findFirst().get(); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + connection = createTopConnection(spcXpdr1, spcXpdr2, cepMap, E_ODU, LayerProtocolName.ODU); + this.connectionFullMap.put(connection.key(), connection); + + // ODU top connection that will be added to the service object + Connection conn = new ConnectionBuilder().setConnectionUuid(connection.getUuid()).build(); + connServMap.put(conn.key(), conn); + + return connServMap; + } + + private Map createXpdrCepsAndConnectionsPht(List xpdrNetworkTplist, + List xpdrNodelist) { + Map connServMap = new HashMap<>(); + Map cepMap = new HashMap<>(); + + // create ceps and x connections within xpdr + for (String xpdr:xpdrNodelist) { + LOG.info("Creating ceps and xc for xpdr {}", xpdr); + String spcXpdrNetwork = xpdrNetworkTplist.stream().filter(netp -> netp.contains(xpdr)).findFirst().get(); + // There should be 1 network tp per xpdr + // TODO photonic media model should be updated to have the corresponding CEPs. I will just create + // 3 different MC CEPs giving different IDs to show that they are different + // Create 3 CEPs for each xpdr otsi node and the corresponding cross connection matchin the NEPs + ConnectionEndPoint netCep1 = createCepXpdr(spcXpdrNetwork, PHTNC_MEDIA, OTSI, + LayerProtocolName.PHOTONICMEDIA); + putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, PHTNC_MEDIA, OTSI, netCep1); + ConnectionEndPoint netCep2 = createCepXpdr(spcXpdrNetwork, E_OTSI, OTSI, LayerProtocolName.PHOTONICMEDIA); + putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, E_OTSI, OTSI, netCep2); + ConnectionEndPoint netCep3 = createCepXpdr(spcXpdrNetwork, I_OTSI, OTSI, LayerProtocolName.PHOTONICMEDIA); + putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, I_OTSI, OTSI, netCep3); + cepMap.put(netCep1.key(), netCep1); + cepMap.put(netCep2.key(), netCep2); + cepMap.put(netCep3.key(), netCep3); + + // Create x connection between I_OTSi and E_OTSi within xpdr + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + connection = createXCBetweenCeps(netCep2, netCep3, spcXpdrNetwork, spcXpdrNetwork, OTSI, + LayerProtocolName.PHOTONICMEDIA); + this.connectionFullMap.put(connection.key(), connection); + + // Create X connection that will be added to the service object + Connection conn = new ConnectionBuilder().setConnectionUuid(connection.getUuid()).build(); + connServMap.put(conn.key(), conn); + } + // OTSi top connection between edge I_OTSI Xpdr + String spcXpdr1 = xpdrNetworkTplist.stream().filter(adp -> adp.contains(xpdrNodelist + .get(0))).findFirst().get(); + String spcXpdr2 = xpdrNetworkTplist.stream().filter(adp -> adp.contains(xpdrNodelist + .get(xpdrNodelist.size() - 1))).findFirst().get(); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + connection = createTopConnection(spcXpdr1, spcXpdr2, cepMap, I_OTSI, LayerProtocolName.PHOTONICMEDIA); + this.connectionFullMap.put(connection.key(), connection); + + // OTSi top connection that will be added to the service object + Connection conn = new ConnectionBuilder().setConnectionUuid(connection.getUuid()).build(); + connServMap.put(conn.key(), conn); + + + return connServMap; + } + + private Map createRoadmCepsAndConnections(List rdmAddDropTplist, + List rdmDegTplist, + List rdmNodelist, + String edgeRoadm1, String edgeRoadm2) { + // TODO: will need to check if things exist already or not + Map connServMap = new HashMap<>(); + Map cepMap = new HashMap<>(); + // create ceps and x connections within roadm + for (String roadm : rdmNodelist) { + LOG.info("Creating ceps and xc for roadm {}", roadm); + String spcRdmAD = rdmAddDropTplist.stream().filter(adp -> adp.contains(roadm)).findFirst().get(); + LOG.info("AD port of ROADm {} = {}", roadm, spcRdmAD); + // There should be only 1 AD and 1 DEG per roadm + // TODO photonic media model should be updated to have the corresponding CEPs. I will just create + // 3 different MC CEPs giving different IDs to show that they are different + // Create 3 CEPs for each AD and DEG and the corresponding cross connections, matching the NEPs + // created in the topology creation + // add CEPs to the topology to the corresponding ONEP + ConnectionEndPoint adCep1 = createCepRoadm(spcRdmAD, PHTNC_MEDIA); + putRdmCepInTopologyContext(roadm, spcRdmAD, PHTNC_MEDIA, adCep1); + ConnectionEndPoint adCep2 = createCepRoadm(spcRdmAD, MC); + putRdmCepInTopologyContext(roadm, spcRdmAD, MC, adCep2); + ConnectionEndPoint adCep3 = createCepRoadm(spcRdmAD, OTSI_MC); + putRdmCepInTopologyContext(roadm, spcRdmAD, OTSI_MC, adCep3); + cepMap.put(adCep1.key(), adCep1); + cepMap.put(adCep2.key(), adCep2); + cepMap.put(adCep3.key(), adCep3); + + String spcRdmDEG = rdmDegTplist.stream().filter(adp -> adp.contains(roadm)).findFirst().get(); + LOG.info("Degree port of ROADm {} = {}", roadm, spcRdmDEG); + + ConnectionEndPoint degCep1 = createCepRoadm(spcRdmDEG, PHTNC_MEDIA); + putRdmCepInTopologyContext(roadm, spcRdmDEG, PHTNC_MEDIA, degCep1); + ConnectionEndPoint degCep2 = createCepRoadm(spcRdmDEG, MC); + putRdmCepInTopologyContext(roadm, spcRdmDEG, MC, degCep2); + ConnectionEndPoint degCep3 = createCepRoadm(spcRdmDEG, OTSI_MC); + putRdmCepInTopologyContext(roadm, spcRdmDEG, OTSI_MC, degCep3); + cepMap.put(degCep1.key(), degCep1); + cepMap.put(degCep2.key(), degCep2); + cepMap.put(degCep3.key(), degCep3); + + LOG.info("Going to create cross connections for ROADM {}", roadm); + // Create X connections between MC and OTSi_MC for full map + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + connection1 = createXCBetweenCeps(adCep2, degCep2, spcRdmAD, spcRdmDEG, MC, + LayerProtocolName.PHOTONICMEDIA); + LOG.info("Cross connection 1 created = {}", connection1); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + connection2 = createXCBetweenCeps(adCep3, degCep3, spcRdmAD, spcRdmDEG, OTSI_MC, + LayerProtocolName.PHOTONICMEDIA); + LOG.info("Cross connection 2 created = {}", connection2); + this.connectionFullMap.put(connection1.key(), connection1); + this.connectionFullMap.put(connection2.key(), connection2); + + // Create X connections that will be added to the service object + Connection conn1 = new ConnectionBuilder().setConnectionUuid(connection1.getUuid()).build(); + Connection conn2 = new ConnectionBuilder().setConnectionUuid(connection2.getUuid()).build(); + connServMap.put(conn1.key(), conn1); + connServMap.put(conn2.key(), conn2); + } + LOG.info("Going to create top connections betwee roadms"); + // create top connections between roadms: MC connections between AD MC CEPs of roadms + for (int i = 0; i < rdmNodelist.size(); i++) { + if (rdmNodelist.size() <= (i + 1)) { + LOG.info("Reached last roadm. No more MC connections"); + break; + } + // Current roadm with roadm i + 1 --> MC + String roadm1 = rdmNodelist.get(i); + String spcRdmAD1 = rdmAddDropTplist.stream().filter(adp -> adp.contains(roadm1)).findFirst().get(); + String roadm2 = rdmNodelist.get(i + 1); + String spcRdmAD2 = rdmAddDropTplist.stream().filter(adp -> adp.contains(roadm2)).findFirst().get(); + LOG.info("Creating top connection from {} to {} between tps: {}-{}", roadm1, roadm2, spcRdmAD1, spcRdmAD2); + + // Create top connections between MC for full map + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + connection = createTopConnection(spcRdmAD1, spcRdmAD2, cepMap, MC, LayerProtocolName.PHOTONICMEDIA); + this.connectionFullMap.put(connection.key(), connection); + LOG.info("Top connection created = {}", connection); + + // Create top connections that will be added to the service object + Connection conn = new ConnectionBuilder().setConnectionUuid(connection.getUuid()).build(); + connServMap.put(conn.key(), conn); + } + + // OTSiMC top connection between edge roadms + LOG.info("Going to created top connection between OTSiMC"); + String spcRdmAD1 = rdmAddDropTplist.stream().filter(adp -> adp.contains(edgeRoadm1)).findFirst().get(); + String spcRdmAD2 = rdmAddDropTplist.stream().filter(adp -> adp.contains(edgeRoadm2)).findFirst().get(); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + connection = createTopConnection(spcRdmAD1, spcRdmAD2, cepMap, OTSI_MC, + LayerProtocolName.PHOTONICMEDIA); + this.connectionFullMap.put(connection.key(), connection); + LOG.info("Top connection created = {}", connection); + + // OTSiMC top connections that will be added to the service object + Connection conn = new ConnectionBuilder().setConnectionUuid(connection.getUuid()).build(); + connServMap.put(conn.key(), conn); + return connServMap; + } + + private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + createTopConnection(String tp1, String tp2, + Map cepMap, String qual, LayerProtocolName topPortocol) { + // find cep for each AD MC of roadm 1 and 2 + LOG.info("Top connection name = {}", String.join("+", "TOP", tp1, tp2, qual)); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.ConnectionEndPoint adCep1 = + cepMap.get(new org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey( + new Uuid(UUID.nameUUIDFromBytes((String.join("+", "CEP", tp1.split("\\+")[0], + qual, tp1.split("\\+")[1])).getBytes(Charset.forName("UTF-8"))) + .toString()))); + LOG.info("ADCEP1 = {}", adCep1); + org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPoint cep1 = + new org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPointBuilder() + .setNodeEdgePointUuid(adCep1.getClientNodeEdgePoint() + .values().stream().findFirst().get().getNodeEdgePointUuid()) + .setTopologyUuid(adCep1.getClientNodeEdgePoint() + .values().stream().findFirst().get().getTopologyUuid()) + .setNodeUuid(adCep1.getClientNodeEdgePoint() + .values().stream().findFirst().get().getNodeUuid()) + .setConnectionEndPointUuid(adCep1.getUuid()) + .build(); + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.ConnectionEndPoint adCep2 = + cepMap.get(new org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey( + new Uuid(UUID.nameUUIDFromBytes((String.join("+", "CEP", tp2.split("\\+")[0], + qual, tp2.split("\\+")[1])).getBytes(Charset.forName("UTF-8"))) + .toString()))); + LOG.info("ADCEP2 = {}", adCep2); + org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPoint cep2 = + new org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPointBuilder() + .setNodeEdgePointUuid(adCep2.getClientNodeEdgePoint() + .values().stream().findFirst().get().getNodeEdgePointUuid()) + .setTopologyUuid(adCep2.getClientNodeEdgePoint() + .values().stream().findFirst().get().getTopologyUuid()) + .setNodeUuid(adCep2.getClientNodeEdgePoint() + .values().stream().findFirst().get().getNodeUuid()) + .setConnectionEndPointUuid(adCep1.getUuid()) + .build(); + Map ceps = new HashMap<>(); + ceps.put(cep1.key(), cep1); + ceps.put(cep2.key(), cep2); + Name connName = new NameBuilder() + .setValueName("Connection name") + .setValue(String.join("+", "TOP", tp1, tp2, qual)) + .build(); + // TODO: lower connection, supported link....... + return new org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectionBuilder() + .setUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", "TOP", tp1, tp2, qual)) + .getBytes(Charset.forName("UTF-8"))).toString())) + .setName(Map.of(connName.key(), connName)) + .setConnectionEndPoint(ceps) + .setOperationalState(OperationalState.ENABLED) + .setLayerProtocolName(topPortocol) + .setLifecycleState(LifecycleState.INSTALLED) + .setDirection(ForwardingDirection.BIDIRECTIONAL) + .build(); + } + + private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection + createXCBetweenCeps(ConnectionEndPoint cep1, ConnectionEndPoint cep2, String tp1, String tp2, String qual, + LayerProtocolName xcProtocol) { + LOG.info("Creation cross connection between: {} and {}", tp1, tp2); + LOG.info("Cross connection name = {}", String.join("+", "XC", tp1, tp2, qual)); + LOG.info("CEP1 = {}", cep1.getClientNodeEdgePoint()); + LOG.info("CEP2 = {}", cep2.getClientNodeEdgePoint()); + org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPoint cepServ1 = + new org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPointBuilder() + .setNodeEdgePointUuid(cep1.getClientNodeEdgePoint() + .values().stream().findFirst().get().getNodeEdgePointUuid()) + .setTopologyUuid(cep1.getClientNodeEdgePoint() + .values().stream().findFirst().get().getTopologyUuid()) + .setNodeUuid(cep1.getClientNodeEdgePoint() + .values().stream().findFirst().get().getNodeUuid()) + .setConnectionEndPointUuid(cep1.getUuid()) + .build(); + org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPoint cepServ2 = + new org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPointBuilder() + .setNodeEdgePointUuid(cep2.getClientNodeEdgePoint() + .values().stream().findFirst().get().getNodeEdgePointUuid()) + .setTopologyUuid(cep2.getClientNodeEdgePoint() + .values().stream().findFirst().get().getTopologyUuid()) + .setNodeUuid(cep2.getClientNodeEdgePoint() + .values().stream().findFirst().get().getNodeUuid()) + .setConnectionEndPointUuid(cep2.getUuid()) + .build(); + Map ceps = new HashMap<>(); + ceps.put(cepServ1.key(), cepServ1); + ceps.put(cepServ2.key(), cepServ2); + Name connName = new NameBuilder() + .setValueName("Connection name") + .setValue(String.join("+", "XC", tp1, tp2, qual)) + .build(); + // TODO: lower connection, supported link....... + return new org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectionBuilder() + .setUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", "XC", tp1, tp2, qual)) + .getBytes(Charset.forName("UTF-8"))).toString())) + .setName(Map.of(connName.key(), connName)) + .setConnectionEndPoint(ceps) + .setOperationalState(OperationalState.ENABLED) + .setLayerProtocolName(xcProtocol) + .setLifecycleState(LifecycleState.INSTALLED) + .setDirection(ForwardingDirection.BIDIRECTIONAL) + .build(); + } + + private ConnectionEndPoint createCepRoadm(String id, String qualifier) { + LOG.info("NEP = {}", String.join("+", id.split("\\+")[0], qualifier, id.split("\\+")[1])); + Name cepName = new NameBuilder() + .setValueName("ConnectionEndPoint name") + .setValue(String.join("+", id.split("\\+")[0], qualifier, + id.split("\\+")[1])) + .build(); + ClientNodeEdgePoint cnep = new ClientNodeEdgePointBuilder() + .setNodeEdgePointUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", id.split("\\+")[0], + qualifier, id.split("\\+")[1])).getBytes(Charset.forName("UTF-8"))) + .toString())) + .setNodeUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+",id.split("\\+")[0], + qualifier)).getBytes(Charset.forName("UTF-8"))) + .toString())) + .setTopologyUuid(new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.T0_FULL_MULTILAYER + .getBytes(Charset.forName("UTF-8"))).toString())) + .build(); + // TODO: add augmentation with the corresponding cep-spec (i.e. MC, OTSiMC...) + // TODO: add parent ONEP?? + ConnectionEndPointBuilder cepBldr = new ConnectionEndPointBuilder() + .setUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", "CEP", id.split("\\+")[0], + qualifier, id.split("\\+")[1])).getBytes(Charset.forName("UTF-8"))) + .toString())) + .setClientNodeEdgePoint(Map.of(cnep.key(), cnep)) + .setName(Map.of(cepName.key(), cepName)) + .setConnectionPortRole(PortRole.SYMMETRIC) + .setConnectionPortDirection(PortDirection.BIDIRECTIONAL) + .setOperationalState(OperationalState.ENABLED) + .setLifecycleState(LifecycleState.INSTALLED) + .setLayerProtocolName(LayerProtocolName.PHOTONICMEDIA); + return cepBldr.build(); + } + + private ConnectionEndPoint createCepXpdr(String id, String qualifier, String nodeLayer, + LayerProtocolName cepProtocol) { + Name cepName = new NameBuilder() + .setValueName("ConnectionEndPoint name") + .setValue(String.join("+", id.split("\\+")[0], qualifier, + id.split("\\+")[1])) + .build(); + ClientNodeEdgePoint cnep = new ClientNodeEdgePointBuilder() + .setNodeEdgePointUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", id.split("\\+")[0], + qualifier, id.split("\\+")[1])).getBytes(Charset.forName("UTF-8"))) + .toString())) + .setNodeUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+",id.split("\\+")[0], + nodeLayer)).getBytes(Charset.forName("UTF-8"))) + .toString())) + .setTopologyUuid(new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.T0_FULL_MULTILAYER + .getBytes(Charset.forName("UTF-8"))).toString())) + .build(); + // TODO: add augmentation with the corresponding cep-spec (i.e. MC, OTSiMC...) + // TODO: add parent ONEP?? + ConnectionEndPointBuilder cepBldr = new ConnectionEndPointBuilder() + .setUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", "CEP", id.split("\\+")[0], + qualifier, id.split("\\+")[1])).getBytes(Charset.forName("UTF-8"))) + .toString())) + .setClientNodeEdgePoint(Map.of(cnep.key(), cnep)) + .setName(Map.of(cepName.key(), cepName)) + .setConnectionPortRole(PortRole.SYMMETRIC) + .setConnectionPortDirection(PortDirection.BIDIRECTIONAL) + .setOperationalState(OperationalState.ENABLED) + .setLifecycleState(LifecycleState.INSTALLED) + .setLayerProtocolName(cepProtocol); + return cepBldr.build(); + } + + private EndPoint mapServiceZEndPoint( + org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.ServiceZEnd + serviceZEnd, PathDescription pathDescription) { + EndPointBuilder endPointBuilder = new EndPointBuilder(); + // 1. Service Format: ODU, OTU, ETH + ServiceFormat serviceFormat = serviceZEnd.getServiceFormat(); + String serviceNodeId = serviceZEnd.getNodeId().getValue(); + // Identify SIP name + Uuid sipUuid = getSipIdFromZend(pathDescription.getZToADirection().getZToA(), serviceNodeId, serviceFormat); + LOG.info("Uuid of z end {}", sipUuid); + LayerProtocolName layerProtocols = null; + // Layer protocol name + switch (serviceFormat) { + case Ethernet: + layerProtocols = LayerProtocolName.DSR; + break; + case OTU: + case OC: + layerProtocols = LayerProtocolName.PHOTONICMEDIA; + break; + case ODU: + layerProtocols = LayerProtocolName.ODU; + break; + default: + LOG.error("Service Format not supported"); + } + return endPointBuilder + .setServiceInterfacePoint(new ServiceInterfacePointBuilder() + .setServiceInterfacePointUuid(sipUuid) + .build()) + .setAdministrativeState(AdministrativeState.UNLOCKED) + .setDirection(PortDirection.BIDIRECTIONAL) + .setLifecycleState(LifecycleState.INSTALLED) + .setOperationalState(OperationalState.ENABLED) + .setLayerProtocolName(layerProtocols) + .setCapacity(new CapacityBuilder() + .setTotalSize(new TotalSizeBuilder() + .setValue(Uint64.valueOf(serviceZEnd.getServiceRate())) + .setUnit(CapacityUnit.GBPS) + .build()) + .setBandwidthProfile(new BandwidthProfileBuilder().build()) // TODO: implement bandwidth profile + .build()) + .setProtectionRole(ProtectionRole.WORK) + .setRole(PortRole.SYMMETRIC) + .setLocalId(serviceNodeId) + .build(); + } + + private EndPoint mapServiceAEndPoint( + org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.ServiceAEnd + serviceAEnd, PathDescription pathDescription) { + EndPointBuilder endPointBuilder = new EndPointBuilder(); + // 1. Service Format: ODU, OTU, ETH + ServiceFormat serviceFormat = serviceAEnd.getServiceFormat(); + String serviceNodeId = serviceAEnd.getNodeId().getValue(); + // Identify SIP name + Uuid sipUuid = getSipIdFromAend(pathDescription.getAToZDirection().getAToZ(), serviceNodeId, serviceFormat); + LOG.info("Uuid of a end {}", sipUuid); + LayerProtocolName layerProtocols = null; + // Layer protocol name + switch (serviceFormat) { + case Ethernet: + layerProtocols = LayerProtocolName.DSR; + break; + case OTU: + case OC: + layerProtocols = LayerProtocolName.PHOTONICMEDIA; + break; + case ODU: + layerProtocols = LayerProtocolName.ODU; + break; + default: + LOG.error("Service Format not supported"); + } + return endPointBuilder + .setServiceInterfacePoint(new ServiceInterfacePointBuilder() + .setServiceInterfacePointUuid(sipUuid) + .build()) + .setAdministrativeState(AdministrativeState.UNLOCKED) + .setDirection(PortDirection.BIDIRECTIONAL) + .setLifecycleState(LifecycleState.INSTALLED) + .setOperationalState(OperationalState.ENABLED) + .setLayerProtocolName(layerProtocols) + .setCapacity(new CapacityBuilder() + .setTotalSize(new TotalSizeBuilder() + .setValue(Uint64.valueOf(serviceAEnd.getServiceRate())) + .setUnit(CapacityUnit.GBPS) + .build()) + .setBandwidthProfile(new BandwidthProfileBuilder().build()) // TODO: implement bandwidth profile + .build()) + .setProtectionRole(ProtectionRole.WORK) + .setRole(PortRole.SYMMETRIC) + .setLocalId(serviceNodeId) + .build(); + } + + private Uuid getSipIdFromZend(Map mapztoa, String serviceNodeId, ServiceFormat serviceFormat) { + Uuid zendUuid = null; + if (serviceNodeId.contains("ROADM")) { + // Service from ROADM to ROADM + // AddDrop-AddDrop ports --> MC layer SIPs + ZToA firstElement = mapztoa.values().stream().filter(ztoa -> ztoa.getId().equals("0")).findFirst().get(); + TerminationPoint tp = (TerminationPoint) firstElement.getResource().getResource(); + Uuid sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", + tp.getTpNodeId(), MC, tp.getTpId())).getBytes(Charset.forName("UTF-8"))) + .toString()); + LOG.info("SIP name = {}", String.join("+", tp.getTpNodeId(), MC, tp.getTpId())); + for (ServiceInterfacePoint sip:this.sipMap.values()) { + if (!sip.getUuid().equals(sipUuid)) { + LOG.info("SIP {} doesn match sipname {}", sip.getUuid().getValue(), sipUuid.getValue()); + continue; + } + zendUuid = sip.getUuid(); + break; + } + } else { + // Service from XPDR to XPDR + ZToA firstElement; + TerminationPoint tp; + Uuid sipUuid; + switch (serviceFormat) { + case ODU: + firstElement = mapztoa.values().stream().filter(ztoa -> ztoa.getId().equals("2")).findFirst().get(); + tp = (TerminationPoint) firstElement.getResource().getResource(); + // Network-Network ports --> iODU layer SIPs TODO --> updated to E_ODU + sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", + tp.getTpNodeId(), E_ODU, tp.getTpId())).getBytes(Charset.forName("UTF-8"))) + .toString()); + LOG.info("SIP name = {}", String.join("+", tp.getTpNodeId(), E_ODU, tp.getTpId())); + break; + case OTU: + firstElement = mapztoa.values().stream().filter(ztoa -> ztoa.getId().equals("2")).findFirst().get(); + tp = (TerminationPoint) firstElement.getResource().getResource(); + // Network-Network ports --> iOTSi layer SIPs + sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", + tp.getTpNodeId(), I_OTSI, tp.getTpId())).getBytes(Charset.forName("UTF-8"))) + .toString()); + LOG.info("SIP name = {}", String.join("+", tp.getTpNodeId(), I_OTSI, tp.getTpId())); + break; + case Ethernet: + firstElement = mapztoa.values().stream().filter(ztoa -> ztoa.getId().equals("0")).findFirst().get(); + tp = (TerminationPoint) firstElement.getResource().getResource(); + // Client-client ports --> DSR layer SIPs + sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", + tp.getTpNodeId(), DSR, tp.getTpId())).getBytes(Charset.forName("UTF-8"))) + .toString()); + LOG.info("SIP name = {}", String.join("+", tp.getTpNodeId(), DSR, tp.getTpId())); + break; + default: + sipUuid = null; + LOG.warn("Service format {} not supported (?)", serviceFormat.getName()); + } + for (ServiceInterfacePoint sip:this.sipMap.values()) { + if (!sip.getUuid().equals(sipUuid)) { + LOG.info("SIP {} doesn match sipname {}", sip.getUuid().getValue(), sipUuid.getValue()); + continue; + } + zendUuid = sip.getUuid(); + break; + } + } + return zendUuid; + } + + private Uuid getSipIdFromAend(Map mapatoz, String serviceNodeId, ServiceFormat serviceFormat) { + Uuid aendUuid = null; + LOG.info("ServiceNode = {} and ServiceFormat = {}", serviceNodeId, serviceFormat.getName()); + LOG.info("Map a to z = {}", mapatoz); + if (serviceNodeId.contains("ROADM")) { + // Service from ROADM to ROADM + // AddDrop-AddDrop ports --> MC layer SIPs + AToZ firstElement = mapatoz.values().stream().filter(atoz -> atoz.getId().equals("0")).findFirst().get(); + LOG.info("First element of service path = {}", firstElement.getResource().getResource()); + TerminationPoint tp = (TerminationPoint) firstElement.getResource().getResource(); + Uuid sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", + tp.getTpNodeId(), MC, tp.getTpId())).getBytes(Charset.forName("UTF-8"))) + .toString()); + LOG.info("ROADM SIP name = {}", String.join("+", tp.getTpNodeId(), MC, tp.getTpId())); + for (ServiceInterfacePoint sip:this.sipMap.values()) { + if (!sip.getUuid().equals(sipUuid)) { + LOG.info("SIP {} doesn match sipname {}", sip.getUuid().getValue(), sipUuid.getValue()); + continue; + } + aendUuid = sip.getUuid(); + break; + } + } else { + // Service from XPDR to XPDR + AToZ firstElement; + TerminationPoint tp; + Uuid sipUuid; + switch (serviceFormat) { + case ODU: + firstElement = mapatoz.values().stream().filter(atoz -> atoz.getId().equals("2")).findFirst().get(); + tp = (TerminationPoint) firstElement.getResource().getResource(); + // Network-Network ports --> iODU layer SIPs. TODO -> updated to eODU + sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", + tp.getTpNodeId(), E_ODU, tp.getTpId())).getBytes(Charset.forName("UTF-8"))) + .toString()); + LOG.info("ODU XPDR SIP name = {}", String.join("+", tp.getTpNodeId(), E_ODU, tp.getTpId())); + break; + case OTU: + firstElement = mapatoz.values().stream().filter(atoz -> atoz.getId().equals("2")).findFirst().get(); + tp = (TerminationPoint) firstElement.getResource().getResource(); + // Network-Network ports --> iOTSi layer SIPs + sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", + tp.getTpNodeId(), I_OTSI, tp.getTpId())).getBytes(Charset.forName("UTF-8"))) + .toString()); + LOG.info("OTU XPDR SIP name = {}", String.join("+", tp.getTpNodeId(), I_OTSI, tp.getTpId())); + break; + case Ethernet: + firstElement = mapatoz.values().stream().filter(atoz -> atoz.getId().equals("0")).findFirst().get(); + tp = (TerminationPoint) firstElement.getResource().getResource(); + // Client-client ports --> DSR layer SIPs + sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", + tp.getTpNodeId(), DSR, tp.getTpId())).getBytes(Charset.forName("UTF-8"))) + .toString()); + LOG.info("DSR XPDR SIP name = {}", String.join("+", tp.getTpNodeId(), DSR, tp.getTpId())); + break; + default: + sipUuid = null; + LOG.warn("Service format {} not supported (?)", serviceFormat.getName()); + } + for (ServiceInterfacePoint sip:this.sipMap.values()) { + if (!sip.getUuid().equals(sipUuid)) { + LOG.info("SIP {} doesn match sipname {}", sip.getUuid().getValue(), sipUuid.getValue()); + continue; + } + aendUuid = sip.getUuid(); + break; + } + } + return aendUuid; + } + + private void putRdmCepInTopologyContext(String node, String spcRdmAD, String qual, ConnectionEndPoint cep) { + LOG.info("NEP id before Merge = {}", String.join("+", node, qual, spcRdmAD.split("\\+")[1])); + LOG.info("Node of NEP id before Merge = {}", String.join("+", node, PHTNC_MEDIA)); + // Give uuids so that it is easier to look for things: topology uuid, node uuid, nep uuid, cep + Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.T0_FULL_MULTILAYER + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(String.join("+", node, PHTNC_MEDIA) + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(String.join("+", node, qual, spcRdmAD.split("\\+")[1]) + .getBytes(Charset.forName("UTF-8"))).toString()); + this.tapiContext.updateTopologyWithCep(topoUuid, nodeUuid, nepUuid, cep); + } + + private void putXpdrCepInTopologyContext(String node, String spcXpdrNet, String qual, String nodeLayer, + ConnectionEndPoint cep) { + // Give uuids so that it is easier to look for things: topology uuid, node uuid, nep uuid, cep + Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.T0_FULL_MULTILAYER + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(String.join("+", node, nodeLayer) + .getBytes(Charset.forName("UTF-8"))).toString()); + Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(String.join("+", node, qual, spcXpdrNet.split("\\+")[1]) + .getBytes(Charset.forName("UTF-8"))).toString()); + this.tapiContext.updateTopologyWithCep(topoUuid, nodeUuid, nepUuid, cep); + } + + public Map + getConnectionFullMap() { + return this.connectionFullMap; + } + + private String getIdBasedOnModelVersion(String nodeid) { + return nodeid.matches("[A-Z]{5}-[A-Z0-9]{2}-.*") ? String.join("-", nodeid.split("-")[0], nodeid.split("-")[1]) + : nodeid.split("-")[0]; + } +} diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImpl.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImpl.java index 20dd57795..6172e5435 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImpl.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImpl.java @@ -14,7 +14,6 @@ import java.util.UUID; import org.opendaylight.transportpce.common.OperationResult; import org.opendaylight.transportpce.tapi.utils.GenericServiceEndpoint; import org.opendaylight.transportpce.tapi.utils.MappingUtils; -import org.opendaylight.transportpce.tapi.utils.TapiUtils; import org.opendaylight.transportpce.tapi.validation.CreateConnectivityServiceValidation; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.OrgOpenroadmServiceService; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceCreateInput; @@ -82,7 +81,7 @@ public class TapiConnectivityImpl implements TapiConnectivityService { && map.containsKey(input.getEndPoint().values().stream().skip(1).findFirst().get() .getServiceInterfacePoint() .getServiceInterfacePointUuid())) { - ServiceCreateInput sci = TapiUtils.buildServiceCreateInput( + ServiceCreateInput sci = ConnectivityUtils.buildServiceCreateInput( map.get(input.getEndPoint().values().stream().findFirst().get() .getServiceInterfacePoint() .getServiceInterfacePointUuid()), diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/impl/TapiProvider.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/impl/TapiProvider.java index e8c0bcadc..68c9f0236 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/impl/TapiProvider.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/impl/TapiProvider.java @@ -7,12 +7,15 @@ */ package org.opendaylight.transportpce.tapi.impl; +import java.util.HashMap; import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.mdsal.binding.api.DataBroker; import org.opendaylight.mdsal.binding.api.DataTreeIdentifier; import org.opendaylight.mdsal.binding.api.RpcProviderService; import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.transportpce.common.network.NetworkTransactionService; +import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations; +import org.opendaylight.transportpce.tapi.connectivity.ConnectivityUtils; import org.opendaylight.transportpce.tapi.connectivity.TapiConnectivityImpl; import org.opendaylight.transportpce.tapi.topology.TapiTopologyImpl; import org.opendaylight.transportpce.tapi.topology.TopologyUtils; @@ -42,15 +45,17 @@ public class TapiProvider { private final RpcProviderService rpcProviderService; private ObjectRegistration rpcRegistration; private final OrgOpenroadmServiceService serviceHandler; + private final ServiceDataStoreOperations serviceDataStoreOperations; private final TapiListener tapiListener; private final NetworkTransactionService networkTransactionService; public TapiProvider(DataBroker dataBroker, RpcProviderService rpcProviderService, - OrgOpenroadmServiceService serviceHandler, TapiListener tapiListener, - NetworkTransactionService networkTransactionService) { + OrgOpenroadmServiceService serviceHandler, ServiceDataStoreOperations serviceDataStoreOperations, + TapiListener tapiListener, NetworkTransactionService networkTransactionService) { this.dataBroker = dataBroker; this.rpcProviderService = rpcProviderService; this.serviceHandler = serviceHandler; + this.serviceDataStoreOperations = serviceDataStoreOperations; this.tapiListener = tapiListener; this.networkTransactionService = networkTransactionService; } @@ -64,8 +69,12 @@ public class TapiProvider { LOG.info("Empty TAPI context created: {}", tapiContext.getTapiContext()); TopologyUtils topologyUtils = new TopologyUtils(this.networkTransactionService, this.dataBroker); - TapiInitialORMapping tapiInitialORMapping = new TapiInitialORMapping(topologyUtils, tapiContext); + ConnectivityUtils connectivityUtils = new ConnectivityUtils(this.serviceDataStoreOperations, new HashMap<>(), + tapiContext); + TapiInitialORMapping tapiInitialORMapping = new TapiInitialORMapping(topologyUtils, connectivityUtils, + tapiContext, this.serviceDataStoreOperations); tapiInitialORMapping.performTopoInitialMapping(); + tapiInitialORMapping.performServInitialMapping(); TapiConnectivityImpl tapi = new TapiConnectivityImpl(this.serviceHandler); TapiTopologyImpl topo = new TapiTopologyImpl(this.dataBroker, tapiContext, topologyUtils); diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TopologyUtils.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TopologyUtils.java index 846d533a9..57ea269f6 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TopologyUtils.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TopologyUtils.java @@ -48,7 +48,13 @@ import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.glob import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameBuilder; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.tapi.context.ServiceInterfacePoint; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.tapi.context.ServiceInterfacePointKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.OwnedNodeEdgePoint1; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointKey; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.LinkKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeBuilder; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.Topology; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.TopologyBuilder; @@ -257,14 +263,54 @@ public final class TopologyUtils { public org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.get.topology.details.output.Topology transformTopology(Topology topology) { - return new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210 + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210 + .get.topology.details.output.TopologyBuilder topologyBuilder = + new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210 .get.topology.details.output.TopologyBuilder() .setUuid(topology.getUuid()) .setName(topology.getName()) .setLayerProtocolName(topology.getLayerProtocolName()) .setNode(topology.getNode()) - .setLink(topology.getLink()) - .build(); + .setLink(topology.getLink()); + if (topology.getNode() == null) { + topologyBuilder.setNode(topology.getNode()); + return topologyBuilder.build(); + } + // TODO -> Need to remove CEPs from NEPs. If not error from get Topology details output + Map mapNode = new HashMap<>(); + for (Node node: topology.getNode().values()) { + Map onepMap = new HashMap<>(); + for (OwnedNodeEdgePoint onep: node.getOwnedNodeEdgePoint().values()) { + OwnedNodeEdgePoint1 onep1 = onep.augmentation(OwnedNodeEdgePoint1.class); + if (onep1 == null) { + onepMap.put(onep.key(), onep); + continue; + } + OwnedNodeEdgePointBuilder newOnepBuilder = new OwnedNodeEdgePointBuilder() + .setUuid(onep.getUuid()) + .setLayerProtocolName(onep.getLayerProtocolName()) + .setName(onep.getName()) + .setSupportedCepLayerProtocolQualifier(onep.getSupportedCepLayerProtocolQualifier()) + .setAdministrativeState(onep.getAdministrativeState()) + .setOperationalState(onep.getOperationalState()) + .setLifecycleState(onep.getLifecycleState()) + .setTerminationDirection(onep.getTerminationDirection()) + .setTerminationState(onep.getTerminationState()) + .setLinkPortDirection(onep.getLinkPortDirection()) + .setLinkPortRole(onep.getLinkPortRole()); + if (onep.getMappedServiceInterfacePoint() != null) { + newOnepBuilder.setMappedServiceInterfacePoint(onep.getMappedServiceInterfacePoint()); + } + OwnedNodeEdgePoint nep = newOnepBuilder.build(); + onepMap.put(nep.key(), nep); + } + Node newNode = new NodeBuilder(node) + .setOwnedNodeEdgePoint(onepMap) + .build(); + mapNode.put(newNode.key(), newNode); + } + topologyBuilder.setNode(mapNode); + return topologyBuilder.build(); } } diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/MappingUtils.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/MappingUtils.java index 6aca970f4..a41c34ab6 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/MappingUtils.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/MappingUtils.java @@ -11,6 +11,7 @@ import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; +import org.opendaylight.transportpce.tapi.connectivity.ConnectivityUtils; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceAEnd; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceZEnd; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid; @@ -30,16 +31,16 @@ public final class MappingUtils { private static GenericServiceEndpoint createMapEntry(ServiceEndPoint sep) { if (sep.getEndPoint().getServiceEndPointType().equals(EndPointType.Aend)) { - ServiceAEnd sepG = TapiUtils.buildServiceAEnd(sep.getEndPoint().getNodeId().getValue(), sep.getEndPoint() - .getClli(), sep.getEndPoint().getTxDirection().getPort().getPortDeviceName(), sep.getEndPoint() - .getTxDirection().getPort().getPortName(), + ServiceAEnd sepG = ConnectivityUtils.buildServiceAEnd(sep.getEndPoint().getNodeId().getValue(), + sep.getEndPoint().getClli(), sep.getEndPoint().getTxDirection().getPort().getPortDeviceName(), + sep.getEndPoint().getTxDirection().getPort().getPortName(), sep.getEndPoint().getRxDirection().getPort().getPortDeviceName(), sep.getEndPoint().getRxDirection() .getPort().getPortName()); return new GenericServiceEndpoint(sepG, ServiceEndpointType.SERVICEAEND); } else { - ServiceZEnd sepG = TapiUtils.buildServiceZEnd(sep.getEndPoint().getNodeId().getValue(), sep.getEndPoint() - .getClli(), sep.getEndPoint().getTxDirection().getPort().getPortDeviceName(), sep.getEndPoint() - .getTxDirection().getPort().getPortName(), + ServiceZEnd sepG = ConnectivityUtils.buildServiceZEnd(sep.getEndPoint().getNodeId().getValue(), + sep.getEndPoint().getClli(), sep.getEndPoint().getTxDirection().getPort().getPortDeviceName(), + sep.getEndPoint().getTxDirection().getPort().getPortName(), sep.getEndPoint().getRxDirection().getPort().getPortDeviceName(), sep.getEndPoint().getRxDirection() .getPort().getPortName()); return new GenericServiceEndpoint(sepG, ServiceEndpointType.SERVICEZEND); diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiContext.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiContext.java index b84b5b0ff..521857d6a 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiContext.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiContext.java @@ -24,8 +24,22 @@ import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.tapi import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.tapi.context.ServiceInterfacePointKey; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.Context1; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.Context1Builder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.OwnedNodeEdgePoint1; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.OwnedNodeEdgePoint1Builder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectionKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityService; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityServiceKey; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.context.ConnectivityContextBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.context.topology.context.topology.node.owned.node.edge.point.CepList; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.context.topology.context.topology.node.owned.node.edge.point.CepListBuilder; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.context.TopologyContextBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointBuilder; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.NwTopologyServiceBuilder; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.Topology; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.TopologyKey; @@ -160,4 +174,72 @@ public class TapiContext { LOG.error("Failed to merge TAPI SIPs", e); } } + + public void updateConnectivityContext(Map connServMap, + Map connectionFullMap) { + // TODO: verify this is correct. Should we identify the context IID with the context UUID?? + try { + org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.context.ConnectivityContext + connectivityContext = new ConnectivityContextBuilder() + .setConnectivityService(connServMap) + .setConnection(connectionFullMap) + .build(); + InstanceIdentifier connectivitycontextIID = + InstanceIdentifier.builder(Context.class).augmentation(Context1.class) + .child(org.opendaylight.yang.gen.v1.urn + .onf.otcc.yang.tapi.connectivity.rev181210.context.ConnectivityContext.class) + .build(); + // merge in datastore + this.networkTransactionService.merge(LogicalDatastoreType.OPERATIONAL, connectivitycontextIID, + connectivityContext); + this.networkTransactionService.commit().get(); + LOG.info("TAPI connectivity merged successfully."); + } catch (InterruptedException | ExecutionException e) { + LOG.error("Failed to merge TAPI connectivity", e); + } + } + + public void updateTopologyWithCep(Uuid topoUuid, Uuid nodeUuid, Uuid nepUuid, ConnectionEndPoint cep) { + // TODO: verify this is correct. Should we identify the context IID with the context UUID?? + InstanceIdentifier onepIID = InstanceIdentifier.builder(Context.class) + .augmentation(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.Context1.class) + .child(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.context.TopologyContext.class) + .child(Topology.class, new TopologyKey(topoUuid)) + .child(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node.class, + new NodeKey(nodeUuid)) + .child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(nepUuid)) + .build(); + try { + Optional optionalOnep = this.networkTransactionService.read( + LogicalDatastoreType.OPERATIONAL, onepIID).get(); + if (!optionalOnep.isPresent()) { + LOG.error("ONEP is not present in datastore"); + return; + } + OwnedNodeEdgePoint onep = optionalOnep.get(); + LOG.info("ONEP found = {}", onep); + // TODO -> If cep exists -> skip merging to datasore + OwnedNodeEdgePoint1 onep1 = onep.augmentation(OwnedNodeEdgePoint1.class); + if (onep1 != null && onep1.getCepList() != null && onep1.getCepList().getConnectionEndPoint() != null + && onep1.getCepList().getConnectionEndPoint().containsKey(new ConnectionEndPointKey(cep.key()))) { + LOG.info("CEP already in topology, skipping merge"); + return; + } + // Updated ONEP + CepList cepList = new CepListBuilder().setConnectionEndPoint(Map.of(cep.key(), cep)).build(); + OwnedNodeEdgePoint1 onep1Bldr = new OwnedNodeEdgePoint1Builder().setCepList(cepList).build(); + OwnedNodeEdgePoint newOnep = new OwnedNodeEdgePointBuilder(onep) + .addAugmentation(onep1Bldr) + .build(); + LOG.info("New ONEP is {}", newOnep); + // merge in datastore + this.networkTransactionService.merge(LogicalDatastoreType.OPERATIONAL, onepIID, + newOnep); + this.networkTransactionService.commit().get(); + LOG.info("CEP added successfully."); + } catch (InterruptedException | ExecutionException e) { + LOG.error("Couldnt update cep in topology", e); + } + } } diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiInitialORMapping.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiInitialORMapping.java index 337c4eba9..5465d6cc3 100644 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiInitialORMapping.java +++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiInitialORMapping.java @@ -9,10 +9,17 @@ package org.opendaylight.transportpce.tapi.utils; import java.util.HashMap; import java.util.Map; +import java.util.Optional; +import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations; +import org.opendaylight.transportpce.tapi.connectivity.ConnectivityUtils; import org.opendaylight.transportpce.tapi.topology.TapiTopologyException; import org.opendaylight.transportpce.tapi.topology.TopologyUtils; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.Service; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceList; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.tapi.context.ServiceInterfacePoint; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.tapi.context.ServiceInterfacePointKey; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityService; +import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityServiceKey; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.Topology; import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.TopologyKey; import org.slf4j.Logger; @@ -23,10 +30,15 @@ public class TapiInitialORMapping { private static final Logger LOG = LoggerFactory.getLogger(TapiInitialORMapping.class); private final TapiContext tapiContext; private final TopologyUtils topologyUtils; + private final ConnectivityUtils connectivityUtils; + private final ServiceDataStoreOperations serviceDataStoreOperations; - public TapiInitialORMapping(TopologyUtils topologyUtils, TapiContext tapiContext) { + public TapiInitialORMapping(TopologyUtils topologyUtils, ConnectivityUtils connectivityUtils, + TapiContext tapiContext, ServiceDataStoreOperations serviceDataStoreOperations) { this.topologyUtils = topologyUtils; this.tapiContext = tapiContext; + this.connectivityUtils = connectivityUtils; + this.serviceDataStoreOperations = serviceDataStoreOperations; } public void performTopoInitialMapping() { @@ -39,8 +51,31 @@ public class TapiInitialORMapping { this.tapiContext.updateTopologyContext(topologyMap); Map sipMap = this.topologyUtils.getSipMap(); this.tapiContext.updateSIPContext(sipMap); + this.connectivityUtils.setSipMap(sipMap); } catch (TapiTopologyException e) { LOG.error("error building TAPI topology", e); } } + + public void performServInitialMapping() { + Optional optOrServices = this.serviceDataStoreOperations.getServices(); + if (!optOrServices.isPresent()) { + LOG.error("Couldnt obtain OR services from datastore"); + return; + } + ServiceList orServices = optOrServices.get(); + if (orServices.getServices() == null) { + LOG.info("No services in datastore. No mapping needed"); + return; + } + Map connServMap = new HashMap<>(); + for (Service service:orServices.getServices().values()) { + // map services + // connections needed to be created --> looking at path description + ConnectivityService connServ = this.connectivityUtils.mapORServiceToTapiConnectivity(service); + connServMap.put(connServ.key(), connServ); + } + // Put in datastore connectivity services and connections + this.tapiContext.updateConnectivityContext(connServMap, this.connectivityUtils.getConnectionFullMap()); + } } diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiUtils.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiUtils.java deleted file mode 100644 index 24afebda4..000000000 --- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/utils/TapiUtils.java +++ /dev/null @@ -1,158 +0,0 @@ -/* - * Copyright © 2018 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.tapi.utils; - -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.equipment.types.rev181130.OpticTypes; -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.node.types.rev181130.NodeIdType; -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.ConnectionType; -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.RpcActions; -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.sdnc.request.header.SdncRequestHeaderBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.endpoint.RxDirectionBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.endpoint.TxDirectionBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.lgx.LgxBuilder; -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.openroadm.service.rev190531.ServiceCreateInput; -import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceCreateInputBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceAEnd; -import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceAEndBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceZEnd; -import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.create.input.ServiceZEndBuilder; -import org.opendaylight.yangtools.yang.common.Uint32; - -public final class TapiUtils { - - private static final String LGX_PORT_NAME = "Some lgx-port-name"; - private static final String PORT_TYPE = "some port type"; - private static final String LGX_DEVICE_NAME = "Some lgx-device-name"; - private static final String PORT_RACK_VALUE = "000000.00"; - - private TapiUtils() { - } - - public static ServiceCreateInput buildServiceCreateInput(GenericServiceEndpoint sepA, GenericServiceEndpoint sepZ) { - ServiceCreateInputBuilder builtInput = new ServiceCreateInputBuilder(); - ServiceAEnd serviceAEnd = getServiceAEnd(sepA, sepZ); - ServiceZEnd serviceZEnd = getServiceZEnd(sepA, sepZ); - if (serviceAEnd != null && serviceZEnd != null) { - builtInput.setCommonId("commonId"); - builtInput.setConnectionType(ConnectionType.Service); - builtInput.setCustomer("Customer"); - builtInput.setServiceName("service test"); - builtInput.setServiceAEnd(serviceAEnd); - builtInput.setServiceZEnd(serviceZEnd); - builtInput.setSdncRequestHeader(new SdncRequestHeaderBuilder().setRequestId("request-1") - .setRpcAction(RpcActions.ServiceCreate).setNotificationUrl("notification url").setRequestSystemId( - "appname") - .build()); - } else { - return null; - } - return builtInput.build(); - } - - public static ServiceAEnd buildServiceAEnd(String nodeid, String clli, String txPortDeviceName, - String txPortName, String rxPortDeviceName, String rxPortName) { - return new ServiceAEndBuilder() - .setClli(clli) - .setNodeId(new NodeIdType(nodeid)) - .setOpticType(OpticTypes.Gray) - .setServiceFormat(ServiceFormat.Ethernet) - .setServiceRate(Uint32.valueOf(100)) - .setTxDirection(new TxDirectionBuilder() - .setPort(new PortBuilder() - .setPortDeviceName(txPortDeviceName) - .setPortName(txPortName) - .setPortRack(PORT_RACK_VALUE) - .setPortShelf("00") - .setPortType(PORT_TYPE) - .build()) - .setLgx(new LgxBuilder() - .setLgxDeviceName(LGX_DEVICE_NAME) - .setLgxPortName(LGX_PORT_NAME) - .setLgxPortRack(PORT_RACK_VALUE) - .setLgxPortShelf("00") - .build()) - .build()) - .setRxDirection(new RxDirectionBuilder() - .setPort(new PortBuilder() - .setPortDeviceName(rxPortDeviceName) - .setPortName(rxPortName) - .setPortRack(PORT_RACK_VALUE) - .setPortShelf("00") - .setPortType(PORT_TYPE) - .build()) - .setLgx(new LgxBuilder() - .setLgxDeviceName(LGX_DEVICE_NAME) - .setLgxPortName(LGX_PORT_NAME) - .setLgxPortRack(PORT_RACK_VALUE) - .setLgxPortShelf("00") - .build()) - .build()) - .build(); - } - - public static ServiceZEnd buildServiceZEnd(String nodeid, String clli, String txPortDeviceName, - String txPortName, String rxPortDeviceName, String rxPortName) { - return new ServiceZEndBuilder().setClli(clli).setNodeId(new NodeIdType(nodeid)) - .setOpticType(OpticTypes.Gray) - .setServiceFormat(ServiceFormat.Ethernet) - .setServiceRate(Uint32.valueOf(100)) - .setTxDirection(new TxDirectionBuilder() - .setPort(new PortBuilder() - .setPortDeviceName(txPortDeviceName) - .setPortName(txPortName) - .setPortRack(PORT_RACK_VALUE) - .setPortShelf("00") - .setPortType(PORT_TYPE) - .build()) - .setLgx(new LgxBuilder() - .setLgxDeviceName(LGX_DEVICE_NAME) - .setLgxPortName(LGX_PORT_NAME) - .setLgxPortRack(PORT_RACK_VALUE) - .setLgxPortShelf("00") - .build()) - .build()) - .setRxDirection(new RxDirectionBuilder() - .setPort(new PortBuilder() - .setPortDeviceName(rxPortDeviceName) - .setPortName(rxPortName) - .setPortRack(PORT_RACK_VALUE) - .setPortShelf("00") - .setPortType(PORT_TYPE) - .build()) - .setLgx(new LgxBuilder() - .setLgxDeviceName(LGX_DEVICE_NAME) - .setLgxPortName(LGX_PORT_NAME) - .setLgxPortRack(PORT_RACK_VALUE) - .setLgxPortShelf("00") - .build()) - .build()) - .build(); - } - - private static ServiceAEnd getServiceAEnd(GenericServiceEndpoint sepA, GenericServiceEndpoint sepZ) { - if (sepA.getType().equals(ServiceEndpointType.SERVICEAEND)) { - return new ServiceAEndBuilder(sepA.getValue()).build(); - } else if (sepZ.getType().equals(ServiceEndpointType.SERVICEAEND)) { - return new ServiceAEndBuilder(sepZ.getValue()).build(); - } else { - return null; - } - } - - private static ServiceZEnd getServiceZEnd(GenericServiceEndpoint sepA, GenericServiceEndpoint sepZ) { - if (sepA.getType().equals(ServiceEndpointType.SERVICEZEND)) { - return new ServiceZEndBuilder(sepA.getValue()).build(); - } else if (sepZ.getType().equals(ServiceEndpointType.SERVICEZEND)) { - return new ServiceZEndBuilder(sepZ.getValue()).build(); - } else { - return null; - } - } -} diff --git a/tapi/src/main/resources/OSGI-INF/blueprint/tapi-blueprint.xml b/tapi/src/main/resources/OSGI-INF/blueprint/tapi-blueprint.xml index 31c00bb6e..293ad605b 100644 --- a/tapi/src/main/resources/OSGI-INF/blueprint/tapi-blueprint.xml +++ b/tapi/src/main/resources/OSGI-INF/blueprint/tapi-blueprint.xml @@ -25,6 +25,9 @@ Author: Gilles Thouenon + + @@ -35,6 +38,7 @@ Author: Gilles Thouenon + diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java index 41685f05e..241f27591 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java @@ -18,6 +18,7 @@ import com.google.common.util.concurrent.ListeningExecutorService; import com.google.common.util.concurrent.MoreExecutors; import java.nio.charset.Charset; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; import java.util.UUID; import java.util.concurrent.CountDownLatch; @@ -31,6 +32,9 @@ import org.opendaylight.transportpce.common.InstanceIdentifiers; import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; import org.opendaylight.transportpce.common.network.NetworkTransactionService; import org.opendaylight.transportpce.common.network.RequestProcessor; +import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations; +import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperationsImpl; +import org.opendaylight.transportpce.tapi.connectivity.ConnectivityUtils; import org.opendaylight.transportpce.tapi.utils.TapiContext; import org.opendaylight.transportpce.tapi.utils.TapiInitialORMapping; import org.opendaylight.transportpce.tapi.utils.TapiTopologyDataUtils; @@ -67,6 +71,8 @@ public class TapiTopologyImplTest extends AbstractTest { public static NetworkTransactionService networkTransactionService; public static TapiContext tapiContext; public static TopologyUtils topologyUtils; + public static ConnectivityUtils connectivityUtils; + public static ServiceDataStoreOperations serviceDataStoreOperations; public static TapiInitialORMapping tapiInitialORMapping; @BeforeClass @@ -83,9 +89,12 @@ public class TapiTopologyImplTest extends AbstractTest { TapiTopologyDataUtils.PORTMAPPING_FILE); networkTransactionService = new NetworkTransactionImpl( new RequestProcessor(getDataStoreContextUtil().getDataBroker())); + serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(getDataStoreContextUtil().getDataBroker()); tapiContext = new TapiContext(networkTransactionService); topologyUtils = new TopologyUtils(networkTransactionService, getDataStoreContextUtil().getDataBroker()); - tapiInitialORMapping = new TapiInitialORMapping(topologyUtils, tapiContext); + connectivityUtils = new ConnectivityUtils(serviceDataStoreOperations, new HashMap<>(), tapiContext); + tapiInitialORMapping = new TapiInitialORMapping(topologyUtils, connectivityUtils, + tapiContext, serviceDataStoreOperations); tapiInitialORMapping.performTopoInitialMapping(); LOG.info("setup done"); } -- 2.36.6