} else {
// create a new mapping
mpBldr = new MappingBuilder();
- String nodeIdLcp = nodeId + logicalConnectionPoint;
+ String nodeIdLcp = nodeId + "-" + logicalConnectionPoint;
mpBldr.withKey(new MappingKey(logicalConnectionPoint))
.setLogicalConnectionPoint(logicalConnectionPoint)
.setSupportingCircuitPackName(circuitPackName)
mpBldr = new MappingBuilder(mapping).setConnectionMapLcp(connectionMapLcp);
} else {
// create a new mapping
- String nodeIdLcp = nodeId + logicalConnectionPoint;
+ String nodeIdLcp = nodeId + "-" + logicalConnectionPoint;
mpBldr = new MappingBuilder()
.withKey(new MappingKey(logicalConnectionPoint))
.setLogicalConnectionPoint(logicalConnectionPoint)
.setSupportingCircuitPackName(circuitPackName)
.setSupportingPort(port.getPortName())
.setPortDirection(port.getPortDirection().getName())
- // fnv hash is generated for the combination nodeID and logical connection point; used for SAPI/DAPI
.setLcpHashVal(fnv(nodeIdLcp));
if (port.getPortQual() != null) {
"supported-interface-capability": [
"org-openroadm-port-types:if-OCH"
],
- "lcp-hash-val": "8e128ba57560403cfd4ffafae38cd942",
+ "lcp-hash-val": "783222141",
"supporting-circuit-pack-name": "1/0/2-PLUG-NET"
},
{
"supported-interface-capability": [
"org-openroadm-port-types:if-OCH"
],
- "lcp-hash-val": "8e128ba57560403cfd4ffafae38cd941",
+ "lcp-hash-val": "-817959205",
"supporting-circuit-pack-name": "1/0/1-PLUG-NET"
},
{
"supported-interface-capability": [
"org-openroadm-port-types:if-100GE"
],
- "lcp-hash-val": "3ed8ed1336784ac7c2f66c22f2f03d8",
+ "lcp-hash-val": "-593641522",
"supporting-circuit-pack-name": "1/0/1-PLUG-CLIENT"
},
{
"supported-interface-capability": [
"org-openroadm-port-types:if-100GE"
],
- "lcp-hash-val": "3ed8ed1336784ac7c2f66c22f2f03db",
+ "lcp-hash-val": "-593641521",
"supporting-circuit-pack-name": "1/0/2-PLUG-CLIENT"
}
],
"supported-interface-capability": [
"org-openroadm-port-types:if-OCH-OTU4-ODU4"
],
- "lcp-hash-val": "1021db8d2affe7386705c438c67ea21f",
+ "lcp-hash-val": "819687633",
"xponder-type": "mpdr",
"supporting-circuit-pack-name": "CP1-CFP0"
},
"org-openroadm-port-types:if-100GE-ODU4",
"org-openroadm-port-types:if-100GE"
],
- "lcp-hash-val": "5ccce78a8e7367129679913aaa905e18",
+ "lcp-hash-val": "-1655532004",
"supporting-circuit-pack-name": "CP2-QSFP4"
},
{
"org-openroadm-port-types:if-100GE-ODU4",
"org-openroadm-port-types:if-100GE"
],
- "lcp-hash-val": "5ccce78a8e7367129679913aaa905e1e",
+ "lcp-hash-val": "-1655532006",
"supporting-circuit-pack-name": "CP2-QSFP2"
},
{
"org-openroadm-port-types:if-100GE-ODU4",
"org-openroadm-port-types:if-100GE"
],
- "lcp-hash-val": "5ccce78a8e7367129679913aaa905e1f",
+ "lcp-hash-val": "-1655532005",
"supporting-circuit-pack-name": "CP2-QSFP3"
},
{
"org-openroadm-port-types:if-100GE-ODU4",
"org-openroadm-port-types:if-100GE"
],
- "lcp-hash-val": "5ccce78a8e7367129679913aaa905e1d",
+ "lcp-hash-val": "-1655532007",
"supporting-circuit-pack-name": "CP2-QSFP1"
},
{
"org-openroadm-port-types:if-10GE-ODU2e",
"org-openroadm-port-types:if-10GE-ODU2"
],
- "lcp-hash-val": "8b3efff522736722500b5e68fb6e696c",
+ "lcp-hash-val": "151922458",
"supporting-circuit-pack-name": "CP1-SFP2"
},
{
"org-openroadm-port-types:if-10GE-ODU2",
"org-openroadm-port-types:if-10GE"
],
- "lcp-hash-val": "8b3efff522736722500b5e68fb6e696b",
+ "lcp-hash-val": "151922459",
"supporting-circuit-pack-name": "CP1-SFP3"
},
{
"org-openroadm-port-types:if-10GE-ODU2",
"org-openroadm-port-types:if-10GE"
],
- "lcp-hash-val": "8b3efff522736722500b5e68fb6e696e",
+ "lcp-hash-val": "151922456",
"supporting-circuit-pack-name": "CP1-SFP4"
},
{
"org-openroadm-port-types:if-10GE-ODU2e",
"org-openroadm-port-types:if-10GE-ODU2"
],
- "lcp-hash-val": "8b3efff522736722500b5e68fb6e696d",
+ "lcp-hash-val": "151922457",
"supporting-circuit-pack-name": "CP1-SFP1"
},
{
"supported-interface-capability": [
"org-openroadm-port-types:if-OCH-OTU4-ODU4"
],
- "lcp-hash-val": "c58e095f5bffd3df5ee0842c78552191",
+ "lcp-hash-val": "623174129",
"xponder-type": "switch",
"supporting-circuit-pack-name": "CP6-CFP"
},
"supported-interface-capability": [
"org-openroadm-port-types:if-OCH-OTU4-ODU4"
],
- "lcp-hash-val": "c58e095f5bffd3df5ee0842c78552192",
+ "lcp-hash-val": "623174128",
"xponder-type": "switch",
"supporting-circuit-pack-name": "CP5-CFP"
},
"supported-interface-capability": [
"org-openroadm-port-types:if-OCH-OTU4-ODU4"
],
- "lcp-hash-val": "c58e095f5bffd3df5ee0842c78552197",
+ "lcp-hash-val": "623174131",
"xponder-type": "switch",
"supporting-circuit-pack-name": "CP8-CFP"
},
"supported-interface-capability": [
"org-openroadm-port-types:if-OCH-OTU4-ODU4"
],
- "lcp-hash-val": "c58e095f5bffd3df5ee0842c78552190",
+ "lcp-hash-val": "623174130",
"xponder-type": "switch",
"supporting-circuit-pack-name": "CP7-CFP"
}
// If node type is transponder
if (inputNodeOptional.isPresent()
&& (inputNodeOptional.get().getNodeInfo().getNodeType() != null)
- && inputNodeOptional.get().getNodeInfo().getNodeType().equals(NodeTypes.Xpdr)) {
+ && inputNodeOptional.get().getNodeInfo().getNodeType().equals(NodeTypes.Xpdr)
+ && destTpId != null) {
Nodes inputNode = inputNodeOptional.get();
OpenroadmVersion openroadmVersion = inputNode.getNodeInfo().getOpenroadmVersion();
LOG.info("Getting data from input node {}", inputNode.getNodeInfo().getNodeType());
LOG.info("Getting mapping data for node is {}", inputNode.getMapping().stream().filter(o -> o.key()
- .equals(new MappingKey(destTpId))).findFirst().toString());
+ .equals(new MappingKey(destTpId))).findFirst().toString());
// If its A-End transponder
if (destTpId.toLowerCase().contains("network")) {
java.util.Optional<Mapping> mappingObject = inputNode.getMapping().stream().filter(o -> o.key()
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInputBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathInput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathInputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.ServicePathInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.ServicePathInputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.ServiceDeleteOutput;
}
public static ServiceImplementationRequestOutput createServiceImplResponse(String responseCode, String message) {
- ServiceImplementationRequestOutputBuilder outputBldr = new ServiceImplementationRequestOutputBuilder()
- .setConfigurationResponseCommon(createCommonResponse(responseCode, message));
- return outputBldr.build();
+ return new ServiceImplementationRequestOutputBuilder()
+ .setConfigurationResponseCommon(createCommonResponse(responseCode, message))
+ .build();
}
public static ServiceDeleteOutput createServiceDeleteResponse(String responseCode, String message) {
- ServiceDeleteOutputBuilder outputBldr = new ServiceDeleteOutputBuilder()
- .setConfigurationResponseCommon(createCommonResponse(responseCode, message));
- return outputBldr.build();
+ return new ServiceDeleteOutputBuilder()
+ .setConfigurationResponseCommon(createCommonResponse(responseCode, message))
+ .build();
}
public static ConfigurationResponseCommon createCommonResponse(String responseCode, String message) {
- ConfigurationResponseCommonBuilder cmBldr = new ConfigurationResponseCommonBuilder()
- .setResponseMessage(message)
- .setResponseCode(responseCode);
- return cmBldr.build();
+ return new ConfigurationResponseCommonBuilder()
+ .setResponseMessage(message)
+ .setResponseCode(responseCode)
+ .build();
}
public static ListenableFuture<RpcResult<ServiceImplementationRequestOutput>>
- createServiceImplementationRpcResponse(ServiceImplementationRequestOutput payload) {
+ createServiceImplementationRpcResponse(ServiceImplementationRequestOutput payload) {
return RpcResultBuilder.success(payload).buildFuture();
}
public static ListenableFuture<RpcResult<ServiceDeleteOutput>>
- createServiceDeleteRpcResponse(ServiceDeleteOutput payload) {
+ createServiceDeleteRpcResponse(ServiceDeleteOutput payload) {
return RpcResultBuilder.success(payload).buildFuture();
}
return new ServicePathInputData(servicePathInputBuilder.build(), nodeLists);
}
+ // Adding createOtnServiceInputpath for A-Z and Z-A directions as one method
+ public static OtnServicePathInput rendererCreateOtnServiceInput(String serviceName, String serviceType,
+ String serviceRate, PathDescription pathDescription, boolean asideToZside) {
+ // If atoZ is set true use A-to-Z direction otherwise use Z-to-A
+ List<org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.otn.renderer.input.Nodes> nodes =
+ new ArrayList<>();
+ NodeLists nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().getAToZ().iterator());
+ if (!asideToZside) {
+ nodeLists = getNodesListZtoA(pathDescription.getZToADirection().getZToA().iterator());
+ }
+ for (Nodes node: nodeLists.getList()) {
+ if (serviceRate.equals("100G")) {
+ nodes.add(
+ new org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.otn.renderer.input
+ .NodesBuilder()
+ .setNodeId(node.getNodeId())
+ .setNetworkTp(node.getDestTp())
+ .build());
+ }
+ else { // For any other service rate (1G or 10G)
+ nodes.add(
+ new org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.otn.renderer.input
+ .NodesBuilder()
+ .setNodeId(node.getNodeId())
+ .setClientTp(node.getSrcTp())
+ .setNetworkTp(node.getDestTp())
+ .build());
+ }
+ }
+ OtnServicePathInputBuilder otnServicePathInputBuilder = new OtnServicePathInputBuilder()
+ .setServiceName(serviceName)
+ .setServiceType(serviceType)
+ .setServiceRate(serviceRate)
+ .setNodes(nodes);
+
+ //TODO: set the trib-slots and trib-ports for the lower oder odu, this should from SH rather than setting here
+ if (serviceRate.equals("1G") || (serviceRate.equals("10G"))) {
+ otnServicePathInputBuilder.setTribPortNumber((short) 1).setTribSlot((short) 1);
+
+ }
+ return otnServicePathInputBuilder.build();
+ }
+
public static ServicePathInput rendererDeleteServiceInput(String serviceName,
ServiceDeleteInput serviceDeleteInput) {
- ServicePathInputBuilder servicePathInput = new ServicePathInputBuilder()
- .setServiceName(serviceName);
//TODO: finish model-model mapping
- return servicePathInput.build();
+ return new ServicePathInputBuilder().setServiceName(serviceName).build();
}
public static NodeLists getNodesListZtoA(Iterator<ZToA> iterator) {
LOG.error("Dont find the getResource method", e);
}
}
-
populateNodeLists(treeMap, list, olmList);
return new NodeLists(olmList, list);
}
LOG.error("Dont find the getResource method", e);
}
}
-
populateNodeLists(treeMap, list, olmList);
return new NodeLists(olmList, list);
}
List<Nodes> list, List<Nodes> olmList) {
String desID = null;
String srcID = null;
+ int cnt = 0; // This is a counter to check for NETWORK_TOKEN
for (NodeIdPair values : treeMap.values()) {
+ cnt++;
if (srcID == null) {
srcID = values.getTpID();
+ // This code is added in support of OTU4 service
+ if ((srcID.contains(StringConstants.NETWORK_TOKEN)) && cnt == 1) {
+ NodesBuilder nb = new NodesBuilder()
+ .withKey(new NodesKey(values.getNodeID()))
+ .setDestTp(srcID) // desTp is assigned to the srcID
+ .setSrcTp(null); // srcTp is set to null to create OTU service
+ list.add(nb.build());
+
+ NodesBuilder olmNb = new NodesBuilder()
+ .setNodeId(values.getNodeID())
+ .setDestTp(srcID) // desTp is assigned to the srcID
+ .setSrcTp(null); // srcTp is set to null to create OTU service
+ olmList.add(olmNb.build());
+ srcID = null;
+ desID = null;
+ continue; // Continue to the next element in the for loop
+ }
+ if ((srcID.contains(StringConstants.NETWORK_TOKEN)) && cnt == treeMap.size()) {
+ // For last node
+ NodesBuilder nb = new NodesBuilder()
+ .withKey(new NodesKey(values.getNodeID()))
+ .setDestTp(srcID) //TODO: check this assignment
+ .setSrcTp(null); //
+ list.add(nb.build());
+
+ NodesBuilder olmNb = new NodesBuilder()
+ .setNodeId(values.getNodeID())
+ .setDestTp(null) // In the case of final node, destTp is set to null
+ .setSrcTp(srcID); // srcTp is srcTp
+ olmList.add(olmNb.build());
+ srcID = null;
+ desID = null;
+ }
+ // End of code for support of ODT4 service
} else if (desID == null) {
desID = values.getTpID();
NodesBuilder nb = new NodesBuilder()
.setTxSapi(portMapA.getLcpHashVal())
.setTxDapi(portMapZ.getLcpHashVal())
.setExpectedDapi(portMapA.getLcpHashVal()) // Setting the expected Dapi and Sapi values
- .setExpectedDapi(portMapZ.getLcpHashVal());
-
+ .setExpectedSapi(portMapZ.getLcpHashVal());
// Create Interface1 type object required for adding as augmentation
// TODO look at imports of different versions of class
// Set the supporting interface data
otuInterfaceBldr.setSupportingInterface(asupportOchInterface);
-
// OTU interface specific data
OtuBuilder otuIfBuilder = new OtuBuilder()
.setFec(OtuAttributes.Fec.Scfec)
.setExpectedDapi(portMapA.getLcpHashVal()) // setting expected SAPI and DAPI values
.setExpectedSapi(portMapZ.getLcpHashVal());
-
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
otuInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
+ org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1.class,
otuIf1Builder.setOtu(otuIfBuilder.build()).build());
// Post interface on the device
@Override
public ServicePathOutput setupServicePath(ServicePathInput input, ServicePathDirection direction) {
List<Nodes> nodes = input.getNodes();
+ Nodes srcNode = nodes.get(0);
+ // If the Node list size is one, then src and tgt are same;
+ // sapi/dapi all have the same value
+ Nodes tgtNode = nodes.get(nodes.size() - 1);
+
+
// Register node for suppressing alarms
if (!alarmSuppressionNodeRegistration(input)) {
LOG.warn("Alarm suppresion node registration failed!!!!");
String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
nodeId, destTp, waveNumber, ModulationFormat.DpQpsk);
createdOchInterfaces.add(supportingOchInterface);
+ // Here we pass logical connection-point of z-end to set SAPI and DAPI
+ String znodeId = tgtNode.getNodeId();
+ String zlogicalConnection = tgtNode.getDestTp();
+ if (nodeId.equals(tgtNode.getNodeId())) {
+ znodeId = srcNode.getNodeId(); // if it is final node, then set zSide as source side
+ zlogicalConnection = srcNode.getDestTp();
+ }
String supportingOtuInterface = this.openRoadmInterfaceFactory
- .createOpenRoadmOtu4Interface(nodeId, destTp, supportingOchInterface);
+ .createOpenRoadmOtu4Interface(nodeId, destTp, supportingOchInterface,
+ znodeId, zlogicalConnection);
createdOtuInterfaces.add(supportingOtuInterface);
if (srcTp == null) {
otnNodesProvisioned.add(node);
success = false;
}
} else {
- LOG.warn("Unsupported serivce-rate for service-type Ethernet");
+ LOG.warn("Unsupported service-rate for service-type Ethernet");
}
break;
case "ODU":
success = false;
}
} else {
- LOG.warn("Unsupported serivce-rate for service-type ODU");
+ LOG.warn("Unsupported service-rate for service-type ODU");
}
break;
default:
- LOG.error("service-type {} not managet yet", input.getServiceType());
+ LOG.error("service-type {} not managed yet", input.getServiceType());
break;
}
if (success) {
--- /dev/null
+/*
+ * Copyright © 2020 AT&T and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.transportpce.renderer.provisiondevice;
+
+import java.util.Collections;
+import java.util.List;
+import org.opendaylight.transportpce.common.OperationResult;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.node.interfaces.NodeInterface;
+
+public final class OtnDeviceRenderingResult extends OperationResult {
+ private final List<NodeInterface> renderedNodeInterfaces;
+
+ private OtnDeviceRenderingResult(boolean success, String message, List<NodeInterface> renderedNodeInterfaces) {
+ super(success, message);
+ if (renderedNodeInterfaces != null) {
+ this.renderedNodeInterfaces = Collections.unmodifiableList(renderedNodeInterfaces);
+ } else {
+ this.renderedNodeInterfaces = Collections.emptyList();
+ }
+ }
+
+ public List<NodeInterface> getRenderedNodeInterfaces() {
+ return this.renderedNodeInterfaces;
+ }
+
+ public static OtnDeviceRenderingResult failed(String message) {
+ return new OtnDeviceRenderingResult(false, message, null);
+ }
+
+ public static OtnDeviceRenderingResult ok(List<NodeInterface> renderedNodeInterfaces) {
+ return new OtnDeviceRenderingResult(true, "", renderedNodeInterfaces);
+ }
+
+}
import org.opendaylight.transportpce.renderer.provisiondevice.tasks.DeviceRenderingTask;
import org.opendaylight.transportpce.renderer.provisiondevice.tasks.OlmPowerSetupRollbackTask;
import org.opendaylight.transportpce.renderer.provisiondevice.tasks.OlmPowerSetupTask;
+import org.opendaylight.transportpce.renderer.provisiondevice.tasks.OtnDeviceRenderingTask;
import org.opendaylight.transportpce.renderer.provisiondevice.tasks.RollbackProcessor;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.TransportpceOlmService;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.Measurements;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.ServiceDeleteInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.ServiceDeleteOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.ServiceImplementationRequestInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.ServiceImplementationRequestOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.ServiceRpcResultSp;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.ServiceRpcResultSpBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev181130.ODU4;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev181130.OTU4;
import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmGranularity;
import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.RpcStatusEx;
private static final String OLM_ROLL_BACK_MSG =
"OLM power setup was not successful! Rendering and OLM will be rolled back.";
private static final String RENDERING_DEVICES_A_Z_MSG = "Rendering devices A-Z";
+ private static final String RENDERING_DEVICES_Z_A_MSG = "Rendering device Z-A";
private static final String TURNING_DOWN_POWER_ON_A_TO_Z_PATH_MSG = "Turning down power on A-to-Z path";
private static final Logger LOG = LoggerFactory.getLogger(RendererServiceOperationsImpl.class);
private static final String FAILED = "Failed";
private static final int NUMBER_OF_THREADS = 4;
private final DeviceRendererService deviceRenderer;
+ private final OtnDeviceRendererService otnDeviceRenderer;
private final TransportpceOlmService olmService;
private final DataBroker dataBroker;
private final NotificationPublishService notificationPublishService;
private NetworkModelWavelengthService networkModelWavelengthService;
private ServiceRpcResultSp notification = null;
- public RendererServiceOperationsImpl(DeviceRendererService deviceRenderer, TransportpceOlmService olmService,
+ public RendererServiceOperationsImpl(DeviceRendererService deviceRenderer,
+ OtnDeviceRendererService otnDeviceRenderer, TransportpceOlmService olmService,
DataBroker dataBroker, NetworkModelWavelengthService networkModelWavelengthService,
NotificationPublishService notificationPublishService) {
this.deviceRenderer = deviceRenderer;
+ this.otnDeviceRenderer = otnDeviceRenderer;
this.olmService = olmService;
this.dataBroker = dataBroker;
this.networkModelWavelengthService = networkModelWavelengthService;
serviceImplementation(ServiceImplementationRequestInput input) {
LOG.info("Calling service impl request {}", input.getServiceName());
return executor.submit(new Callable<ServiceImplementationRequestOutput>() {
-
@Override
public ServiceImplementationRequestOutput call() throws Exception {
sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest, input.getServiceName(),
RpcStatusEx.Pending, "Service compliant, submitting service implementation Request ...");
- RollbackProcessor rollbackProcessor = new RollbackProcessor();
- ServicePathInputData servicePathInputDataAtoZ = ModelMappingUtils
- .rendererCreateServiceInputAToZ(input.getServiceName(), input.getPathDescription());
- ServicePathInputData servicePathInputDataZtoA = ModelMappingUtils
- .rendererCreateServiceInputZToA(input.getServiceName(), input.getPathDescription());
- List<DeviceRenderingResult> renderingResults =
- deviceRendering(rollbackProcessor, servicePathInputDataAtoZ, servicePathInputDataZtoA);
- if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
- sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest, input.getServiceName(),
- RpcStatusEx.Failed, DEVICE_RENDERING_ROLL_BACK_MSG);
- return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED, OPERATION_FAILED);
- }
- ServicePowerSetupInput olmPowerSetupInputAtoZ =
- ModelMappingUtils.createServicePowerSetupInput(renderingResults.get(0).getOlmList(), input);
- ServicePowerSetupInput olmPowerSetupInputZtoA =
- ModelMappingUtils.createServicePowerSetupInput(renderingResults.get(1).getOlmList(), input);
- olmPowerSetup(rollbackProcessor, olmPowerSetupInputAtoZ, olmPowerSetupInputZtoA);
- if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
- sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest, input.getServiceName(),
- RpcStatusEx.Failed,
- OLM_ROLL_BACK_MSG);
- return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED, OPERATION_FAILED);
+ // Here is the switch statement that distinguishes on the connection-type
+ LOG.info("Connection-type is {} for {}", input.getConnectionType(), input.getServiceName());
+ switch (input.getConnectionType()) {
+ case Service: // This takes into account of Ethernet 100G, 1G, 10G and ODU4
+ LOG.info("RPC implementation for {}", input.getConnectionType());
+ if ((input.getServiceAEnd().getServiceRate() != null) // Since service-rate could be null
+ && (input.getServiceAEnd().getServiceRate().intValue() == 100)
+ && (input.getServiceAEnd().getServiceFormat().getName().equals("Ethernet"))) {
+ LOG.info("Service format for {} is {} and rate is {}", input.getServiceName(),
+ input.getServiceAEnd().getServiceFormat(), input.getServiceAEnd().getServiceRate());
+ ServicePathInputData servicePathInputDataAtoZ = ModelMappingUtils
+ .rendererCreateServiceInputAToZ(input.getServiceName(), input.getPathDescription());
+ ServicePathInputData servicePathInputDataZtoA = ModelMappingUtils
+ .rendererCreateServiceInputZToA(input.getServiceName(), input.getPathDescription());
+ // Rollback should be same for all conditions, so creating a new one
+ RollbackProcessor rollbackProcessor = new RollbackProcessor();
+ List<DeviceRenderingResult> renderingResults =
+ deviceRendering(rollbackProcessor, servicePathInputDataAtoZ, servicePathInputDataZtoA);
+ if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Failed, DEVICE_RENDERING_ROLL_BACK_MSG);
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
+ ServicePowerSetupInput olmPowerSetupInputAtoZ =
+ ModelMappingUtils.createServicePowerSetupInput(renderingResults.get(0).getOlmList(),
+ input);
+ ServicePowerSetupInput olmPowerSetupInputZtoA =
+ ModelMappingUtils.createServicePowerSetupInput(renderingResults.get(1).getOlmList(),
+ input);
+ olmPowerSetup(rollbackProcessor, olmPowerSetupInputAtoZ, olmPowerSetupInputZtoA);
+ if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Failed, OLM_ROLL_BACK_MSG);
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
+ // run service activation test twice - once on source node and once on
+ // destination node
+ List<Nodes> nodes = servicePathInputDataAtoZ.getServicePathInput().getNodes();
+ if ((nodes == null) || (nodes.isEmpty())) {
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
+ Nodes sourceNode = nodes.get(0);
+ Nodes destNode = nodes.get(nodes.size() - 1);
+ String srcNetworkTp;
+ String dstNetowrkTp;
+ if (sourceNode.getDestTp().contains(StringConstants.NETWORK_TOKEN)) {
+ srcNetworkTp = sourceNode.getDestTp();
+ } else {
+ srcNetworkTp = sourceNode.getSrcTp();
+ }
+ if (destNode.getDestTp().contains(StringConstants.NETWORK_TOKEN)) {
+ dstNetowrkTp = destNode.getDestTp();
+ } else {
+ dstNetowrkTp = destNode.getSrcTp();
+ }
+ if (!isServiceActivated(sourceNode.getNodeId(), srcNetworkTp)
+ || !isServiceActivated(destNode.getNodeId(), dstNetowrkTp)) {
+ rollbackProcessor.rollbackAll();
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Failed,
+ "Service activation test failed.");
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
+ // If Service activation is success update Network ModelMappingUtils
+ networkModelWavelengthService.useWavelengths(input.getPathDescription());
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL);
+ } else { // This implies, service-rate is 1 or 10G
+ // This includes the lower-order odu (1 G, 10 G) and
+ LOG.info("RPC implementation for LO-ODU");
+ String serviceRate = ""; // Assuming service at A-side and Z-side has same service rate
+ if (input.getServiceAEnd().getServiceRate() != null) {
+ serviceRate = input.getServiceAEnd().getServiceRate().toString() + "G";
+ }
+ LOG.info("Start rendering for {} service with {} rate and {} format",
+ input.getServiceName(), serviceRate,
+ input.getServiceAEnd().getServiceFormat());
+ // TODO: Need to create OCH-OTU4 interfaces by calling service-path input without src-tp
+ // This is A-Z side
+ OtnServicePathInput otnServicePathInputAtoZ = ModelMappingUtils
+ .rendererCreateOtnServiceInput(input.getServiceName(),
+ input.getServiceAEnd().getServiceFormat().getName(),
+ serviceRate, input.getPathDescription(), true);
+ // This is Z-A side
+ OtnServicePathInput otnServicePathInputZtoA = ModelMappingUtils
+ .rendererCreateOtnServiceInput(input.getServiceName(),
+ input.getServiceZEnd().getServiceFormat().getName(),
+ serviceRate, input.getPathDescription(), false);
+ // Rollback should be same for all conditions, so creating a new one
+ RollbackProcessor rollbackProcessor = new RollbackProcessor();
+ List<OtnDeviceRenderingResult> otnRenderingResults = otnDeviceRendering(rollbackProcessor,
+ otnServicePathInputAtoZ, otnServicePathInputZtoA);
+ if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Failed, DEVICE_RENDERING_ROLL_BACK_MSG);
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
+ LOG.info("OTN rendering result size {}", otnRenderingResults.size());
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL);
+ }
+ break;
+ case Infrastructure:
+ LOG.info("RPC implementation for {}", input.getConnectionType());
+ if ((input.getServiceAEnd().getOtuServiceRate() != null)
+ && (input.getServiceAEnd().getOtuServiceRate().equals(OTU4.class))) {
+ // For the service of OTU4 infrastructure
+ // First create the OCH and OTU interfaces
+ String serviceRate = "100G"; // For OtnDeviceRendererServiceImpl
+ LOG.info("Service format for {} is {} and rate is {}", input.getServiceName(),
+ input.getServiceAEnd().getOtuServiceRate(), serviceRate);
+ // First render OCH and OTU interfaces
+ ServicePathInputData servicePathInputDataAtoZ = ModelMappingUtils
+ .rendererCreateServiceInputAToZ(input.getServiceName(), input.getPathDescription());
+ ServicePathInputData servicePathInputDataZtoA = ModelMappingUtils
+ .rendererCreateServiceInputZToA(input.getServiceName(), input.getPathDescription());
+ // Rollback should be same for all conditions, so creating a new one
+ RollbackProcessor rollbackProcessor = new RollbackProcessor();
+ List<DeviceRenderingResult> renderingResults =
+ deviceRendering(rollbackProcessor, servicePathInputDataAtoZ, servicePathInputDataZtoA);
+ if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Failed, DEVICE_RENDERING_ROLL_BACK_MSG);
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
+ LOG.info("Starting the OLM power setup");
+ ServicePowerSetupInput olmPowerSetupInputAtoZ =
+ ModelMappingUtils.createServicePowerSetupInput(renderingResults.get(0).getOlmList(),
+ input);
+ ServicePowerSetupInput olmPowerSetupInputZtoA =
+ ModelMappingUtils.createServicePowerSetupInput(renderingResults.get(1).getOlmList(),
+ input);
+ olmPowerSetup(rollbackProcessor, olmPowerSetupInputAtoZ, olmPowerSetupInputZtoA);
+ if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Failed, OLM_ROLL_BACK_MSG);
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
+ // run service activation test twice - once on source node and once on
+ // destination node
+ List<Nodes> nodes = servicePathInputDataAtoZ.getServicePathInput().getNodes();
+ if ((nodes == null) || (nodes.isEmpty())) {
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
+ Nodes srcNode = nodes.get(0);
+ Nodes tgtNode = nodes.get(nodes.size() - 1); // destination node or target node
+ String srcNetworkTp = srcNode.getDestTp(); // In this case srcNode only has destTp
+ String tgtNetowrkTp = tgtNode.getSrcTp(); // tgtNode node only has srcTp
+
+ if (!isServiceActivated(srcNode.getNodeId(), srcNetworkTp)
+ || !isServiceActivated(tgtNode.getNodeId(), tgtNetowrkTp)) {
+ rollbackProcessor.rollbackAll();
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Failed,
+ "Service activation test failed.");
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
+ }
+ if ((input.getServiceAEnd().getOduServiceRate() != null)
+ && (input.getServiceAEnd().getOduServiceRate().equals(ODU4.class))) {
+ // For the service of OTU4 infrastructure
+ // First create the OCH and OTU interfaces
+ String serviceRate = "100G"; // For OtnDeviceRendererServiceImpl
+ LOG.info("Service format for {} is {} and rate is {}", input.getServiceName(),
+ input.getServiceAEnd().getOtuServiceRate(), serviceRate);
+ // Now start rendering ODU4 interface
+ String serviceFormat = "ODU"; // Since we need to create ODU4 Ttp interfaces as well
+ // This is A-Z side
+ OtnServicePathInput otnServicePathInputAtoZ = ModelMappingUtils
+ .rendererCreateOtnServiceInput(input.getServiceName(),
+ serviceFormat, serviceRate, input.getPathDescription(), true);
+ // This is Z-A side
+ OtnServicePathInput otnServicePathInputZtoA = ModelMappingUtils
+ .rendererCreateOtnServiceInput(input.getServiceName(),
+ input.getServiceZEnd().getServiceFormat().getName(),
+ serviceRate, input.getPathDescription(), false);
+ // Rollback should be same for all conditions, so creating a new one
+ RollbackProcessor rollbackProcessor = new RollbackProcessor();
+ List<OtnDeviceRenderingResult> otnRenderingResults = otnDeviceRendering(rollbackProcessor,
+ otnServicePathInputAtoZ, otnServicePathInputZtoA);
+ if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Failed, DEVICE_RENDERING_ROLL_BACK_MSG);
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
+ LOG.info("OTN rendering result size {}", otnRenderingResults.size());
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL);
+ }
+ break;
+ default:
+ LOG.warn("Unsupported connection type {}", input.getConnectionType());
}
- // run service activation test twice - once on source node and once on
- // destination node
- List<Nodes> nodes = servicePathInputDataAtoZ.getServicePathInput().getNodes();
- Nodes sourceNode = nodes.get(0);
- Nodes destNode = nodes.get(nodes.size() - 1);
- String srcNetworkTp;
- String dstNetowrkTp;
- if (sourceNode.getDestTp().contains(StringConstants.NETWORK_TOKEN)) {
- srcNetworkTp = sourceNode.getDestTp();
- } else {
- srcNetworkTp = sourceNode.getSrcTp();
- }
- if (destNode.getDestTp().contains(StringConstants.NETWORK_TOKEN)) {
- dstNetowrkTp = destNode.getDestTp();
- } else {
- dstNetowrkTp = destNode.getSrcTp();
- }
- if (!isServiceActivated(sourceNode.getNodeId(), srcNetworkTp)
- || !isServiceActivated(destNode.getNodeId(), dstNetowrkTp)) {
- rollbackProcessor.rollbackAll();
- sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest, input.getServiceName(),
- RpcStatusEx.Failed, "Service activation test failed.");
- return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED, OPERATION_FAILED);
- }
- // If Service activation is success update Network ModelMappingUtils
- networkModelWavelengthService.useWavelengths(input.getPathDescription());
- sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest, input.getServiceName(),
- RpcStatusEx.Successful, OPERATION_SUCCESSFUL);
- return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_OK, OPERATION_SUCCESSFUL);
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_OK,
+ OPERATION_SUCCESSFUL);
}
+
});
}
LOG.info("Rendering devices Z-A");
sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
- servicePathDataAtoZ.getServicePathInput().getServiceName(), RpcStatusEx.Pending,
- RENDERING_DEVICES_A_Z_MSG);
+ servicePathDataZtoA.getServicePathInput().getServiceName(), RpcStatusEx.Pending,
+ RENDERING_DEVICES_Z_A_MSG);
ListenableFuture<DeviceRenderingResult> ztoarenderingFuture =
this.executor.submit(new DeviceRenderingTask(this.deviceRenderer, servicePathDataZtoA,
ServicePathDirection.Z_TO_A));
return renderingResults;
}
+ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+ value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "call in call() method")
+ private List<OtnDeviceRenderingResult> otnDeviceRendering(RollbackProcessor rollbackProcessor,
+ OtnServicePathInput otnServicePathAtoZ, OtnServicePathInput otnServicePathZtoA) {
+ LOG.info(RENDERING_DEVICES_A_Z_MSG);
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ otnServicePathAtoZ.getServiceName(), RpcStatusEx.Pending,
+ RENDERING_DEVICES_A_Z_MSG);
+ ListenableFuture<OtnDeviceRenderingResult> atozrenderingFuture =
+ this.executor.submit(new OtnDeviceRenderingTask(this.otnDeviceRenderer, otnServicePathAtoZ));
+
+ LOG.info("Rendering devices Z-A");
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ otnServicePathZtoA.getServiceName(), RpcStatusEx.Pending,
+ RENDERING_DEVICES_Z_A_MSG);
+ ListenableFuture<OtnDeviceRenderingResult> ztoarenderingFuture =
+ this.executor.submit(new OtnDeviceRenderingTask(this.otnDeviceRenderer, otnServicePathZtoA));
+ ListenableFuture<List<OtnDeviceRenderingResult>> renderingCombinedFuture =
+ Futures.allAsList(atozrenderingFuture, ztoarenderingFuture);
+
+ List<OtnDeviceRenderingResult> otnRenderingResults = new ArrayList<>(2);
+ try {
+ LOG.info("Waiting for A-Z and Z-A device renderers ...");
+ otnRenderingResults = renderingCombinedFuture.get(Timeouts.RENDERING_TIMEOUT, TimeUnit.MILLISECONDS);
+ } catch (InterruptedException | ExecutionException | TimeoutException e) {
+ LOG.warn(DEVICE_RENDERING_ROLL_BACK_MSG, e);
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ otnServicePathAtoZ.getServiceName(), RpcStatusEx.Pending,
+ DEVICE_RENDERING_ROLL_BACK_MSG);
+ //FIXME we can't do rollback here, because we don't have rendering results.
+ return otnRenderingResults;
+ }
+
+ rollbackProcessor.addTask(new DeviceRenderingRollbackTask("AtoZDeviceTask",
+ ! otnRenderingResults.get(0).isSuccess(), otnRenderingResults.get(0).getRenderedNodeInterfaces(),
+ this.deviceRenderer));
+ rollbackProcessor.addTask(new DeviceRenderingRollbackTask("ZtoADeviceTask",
+ ! otnRenderingResults.get(1).isSuccess(), otnRenderingResults.get(1).getRenderedNodeInterfaces(),
+ this.deviceRenderer));
+
+
+ return otnRenderingResults;
+
+ }
+
@edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
value = "UPM_UNCALLED_PRIVATE_METHOD",
justification = "call in call() method")
--- /dev/null
+/*
+ * Copyright © 2020 AT&T and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.transportpce.renderer.provisiondevice.tasks;
+
+import java.util.concurrent.Callable;
+import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService;
+import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRenderingResult;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathInput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathOutput;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class OtnDeviceRenderingTask implements Callable<OtnDeviceRenderingResult> {
+ private static final Logger LOG = LoggerFactory.getLogger(OtnDeviceRenderingTask.class);
+
+ private final OtnDeviceRendererService otnDeviceRenderer;
+ private final OtnServicePathInput otnServicePathInput;
+
+ public OtnDeviceRenderingTask(OtnDeviceRendererService otnDeviceRendererService,
+ OtnServicePathInput otnServicePathInput) {
+ this.otnDeviceRenderer = otnDeviceRendererService;
+ this.otnServicePathInput = otnServicePathInput;
+
+ }
+
+ @Override
+ public OtnDeviceRenderingResult call() throws Exception {
+ OtnServicePathOutput output = this.otnDeviceRenderer.setupOtnServicePath(this.otnServicePathInput);
+ if (Boolean.TRUE.equals(output.isSuccess())) {
+ LOG.info("Device rendering finished successfully.");
+ return OtnDeviceRenderingResult.ok(output.getNodeInterface());
+
+ } else { //false or null case
+ LOG.warn("Device rendering not successfully finished.");
+ return OtnDeviceRenderingResult.failed("Operation Failed");
+ }
+ }
+
+}
<bean id="rendererServiceOperations" class="org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperationsImpl" >
<argument ref="deviceRenderer" />
+ <argument ref="otnDeviceRenderer"/>
<argument ref="olmService" />
<argument ref="dataBroker" />
<argument ref="networkModelWavelengthService" />
<service ref="deviceRenderer"
interface="org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService" />
-
<service ref="rendererServiceOperations"
interface="org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations" />
<service ref="networkModelWavelengthService"
interface="org.opendaylight.transportpce.renderer.NetworkModelWavelengthService" />
+ <service ref="otnDeviceRenderer"
+ interface="org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService"/>
+
</blueprint>
private PortMappingVersion121 portMappingVersion121;
private CrossConnectImpl121 crossConnectImpl121;
private CrossConnectImpl221 crossConnectImpl221;
+ private OtnDeviceRendererService otnDeviceRendererService;
private void setMountPoint(MountPoint mountPoint) {
MountPointService mountPointService = new MountPointServiceStub(mountPoint);
this.deviceRenderer = new DeviceRendererServiceImpl(this.getDataBroker(),
this.deviceTransactionManager, openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect,
this.portMapping, null);
+
+ this.otnDeviceRendererService = new OtnDeviceRendererServiceImpl(openRoadmInterfaceFactory, crossConnect,
+ openRoadmInterfaces, this.deviceTransactionManager, null);
+
}
@Before
MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUMBER_OF_THREADS));
this.networkModelWavelengthService = new NetworkModelWavelengthServiceImpl(getDataBroker());
NotificationPublishService notificationPublishService = new NotificationPublishServiceMock();
- this.rendererServiceOperations = new RendererServiceOperationsImpl(this.deviceRenderer, olmService,
- getDataBroker(), this.networkModelWavelengthService, notificationPublishService);
+ this.rendererServiceOperations = new RendererServiceOperationsImpl(this.deviceRenderer,
+ this.otnDeviceRendererService, olmService, getDataBroker(), this.networkModelWavelengthService,
+ notificationPublishService);
}
private RendererServiceOperationsImpl rendererServiceOperations;
private OpenRoadmInterfaces openRoadmInterfaces;
private DeviceRendererService deviceRenderer;
+ private OtnDeviceRendererService otnDeviceRendererService;
private PortMapping portMapping;
private OpenRoadmInterfaceFactory openRoadmInterfaceFactory;
private CrossConnect crossConnect;
this.networkModelWavelengthService = new NetworkModelWavelengthServiceImpl(getDataBroker());
this.deviceRenderer = new DeviceRendererServiceImpl(this.getDataBroker(), this.deviceTransactionManager,
openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect, portMapping, null);
+ this.otnDeviceRendererService = new OtnDeviceRendererServiceImpl(openRoadmInterfaceFactory, this.crossConnect,
+ openRoadmInterfaces, this.deviceTransactionManager, null);
Mockito.doNothing().when(this.openRoadmInterfaces).postEquipmentState(Mockito.anyString(),
Mockito.anyString(), Mockito.anyBoolean());
NotificationPublishService notificationPublishService = new NotificationPublishServiceMock();
-
this.olmService = Mockito.spy(this.olmService);
this.deviceRenderer = Mockito.spy(this.deviceRenderer);
- this.rendererServiceOperations = new RendererServiceOperationsImpl(this.deviceRenderer, this.olmService,
- getDataBroker(), this.networkModelWavelengthService, notificationPublishService);
+ this.rendererServiceOperations = new RendererServiceOperationsImpl(this.deviceRenderer,
+ this.otnDeviceRendererService, this.olmService, getDataBroker(), this.networkModelWavelengthService,
+ notificationPublishService);
ServicePathOutputBuilder mockOutputBuilder = new ServicePathOutputBuilder().setResult("success")
.setSuccess(true);
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.service.implementation.request.input.PathDescriptionBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.service.implementation.request.input.ServiceAEndBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.service.implementation.request.input.ServiceZEndBuilder;
+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.service.port.PortBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.format.rev190531.ServiceFormat;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev171017.path.description.AToZDirection;
.setServiceName("service 1").setPathDescription(createPathDescriptionTerminationPointResource(tpId))
.setServiceHandlerHeader(new ServiceHandlerHeaderBuilder().setRequestId("Request 1").build())
.setServiceAEnd(getServiceAEndBuild(tpId).build())
- .setServiceZEnd(getServiceZEndBuild(tpId).build());
+ .setServiceZEnd(getServiceZEndBuild(tpId).build())
+ .setConnectionType(ConnectionType.Service);
return builder.build();
}
.setPort(new PortBuilder().setPortDeviceName("device name").setPortName("port name")
.setPortRack("port rack").setPortShelf("port shelf").setPortSlot("port slot")
.setPortSubSlot("port subslot").setPortType("port type").build())
- .build());
+ .build())
+ .setServiceRate(Long.valueOf(100))
+ .setServiceFormat(ServiceFormat.Ethernet);
}
public static ServiceZEndBuilder getServiceZEndBuild(String tpId) {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-
public final class ModelMappingUtils {
- private static final Logger LOG = LoggerFactory.getLogger(ModelMappingUtils.class);
+ private static final Logger LOG =
+ LoggerFactory.getLogger(org.opendaylight.transportpce.servicehandler.ModelMappingUtils.class);
+ private static final String TERMINATION_POINT = "TerminationPoint";
private ModelMappingUtils() {
}
public static ServiceImplementationRequestInput createServiceImplementationRequest(ServiceInput input,
PathDescription pathDescription) {
-
- org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520
- .service.implementation.request.input.ServiceAEndBuilder serviceAEnd =
- new org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520
- .service.implementation.request.input.ServiceAEndBuilder()
- .setServiceFormat(input.getServiceAEnd().getServiceFormat())
- .setServiceRate(input.getServiceAEnd().getServiceRate())
- .setClli(input.getServiceAEnd().getClli())
- .setNodeId(new NodeIdType(input.getServiceAEnd().getNodeId().getValue()).getValue())
- .setTxDirection(new org.opendaylight.yang.gen.v1.http.org
- .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.TxDirectionBuilder()
- .setPort(input.getServiceAEnd().getTxDirection().getPort())
- .build())
- .setRxDirection(new org.opendaylight.yang.gen.v1.http.org
- .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.RxDirectionBuilder()
- .setPort(input.getServiceAEnd().getRxDirection().getPort())
- .build());
-
- org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520
- .service.implementation.request.input.ServiceZEndBuilder serviceZEnd =
- new org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520
- .service.implementation.request.input.ServiceZEndBuilder()
- .setServiceFormat(input.getServiceZEnd().getServiceFormat())
- .setServiceRate(input.getServiceZEnd().getServiceRate())
- .setClli(input.getServiceZEnd().getClli())
- .setNodeId(new NodeIdType(input.getServiceZEnd().getNodeId().getValue()).getValue())
- .setTxDirection(new org.opendaylight.yang.gen.v1.http.org
- .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.TxDirectionBuilder()
- .setPort(input.getServiceZEnd().getTxDirection().getPort())
- .build())
- .setRxDirection(new org.opendaylight.yang.gen.v1.http.org
- .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.RxDirectionBuilder()
- .setPort(input.getServiceZEnd().getRxDirection().getPort())
- .build());
-
- org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520
- .service.implementation.request.input.PathDescriptionBuilder pathDescBuilder =
- new org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520
- .service.implementation.request.input.PathDescriptionBuilder()
- .setAToZDirection(pathDescription.getAToZDirection())
- .setZToADirection(pathDescription.getZToADirection());
-
ServiceImplementationRequestInputBuilder serviceImplementationRequestInputBuilder =
- new ServiceImplementationRequestInputBuilder();
+ new ServiceImplementationRequestInputBuilder();
if (input.isServiceReconfigure()) {
serviceImplementationRequestInputBuilder.setServiceName(input.getNewServiceName());
} else {
serviceImplementationRequestInputBuilder.setServiceName(input.getServiceName());
}
-
- return serviceImplementationRequestInputBuilder
- .setServiceAEnd(serviceAEnd.build())
- .setServiceZEnd(serviceZEnd.build())
- .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
- .setRequestId(input.getSdncRequestHeader().getRequestId())
- .build())
- .setPathDescription(pathDescBuilder.build())
- .build();
+ org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.service.implementation
+ .request.input.ServiceAEndBuilder serviceAEnd = new org.opendaylight.yang.gen.v1.http.org.opendaylight
+ .transportpce.renderer.rev200520.service.implementation.request.input.ServiceAEndBuilder();
+
+ serviceAEnd.setServiceFormat(input.getServiceAEnd().getServiceFormat())
+ .setServiceRate(input.getServiceAEnd().getServiceRate())
+ .setOtuServiceRate(input.getServiceAEnd().getOtuServiceRate()) // set otu and odu
+ .setOduServiceRate(input.getServiceZEnd().getOduServiceRate())
+ .setClli(input.getServiceAEnd().getClli())
+ .setNodeId(new NodeIdType(input.getServiceAEnd().getNodeId().getValue()).getValue())
+ .setTxDirection(new org.opendaylight.yang.gen.v1.http.org
+ .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.TxDirectionBuilder()
+ .setPort(input.getServiceAEnd().getTxDirection().getPort()).build())
+ .setRxDirection(new org.opendaylight.yang.gen.v1.http.org
+ .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.RxDirectionBuilder()
+ .setPort(input.getServiceAEnd().getRxDirection().getPort()).build());
+ org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.service.implementation
+ .request.input.ServiceZEndBuilder serviceZEnd = new org.opendaylight.yang.gen.v1.http.org.opendaylight
+ .transportpce.renderer.rev200520.service.implementation.request.input.ServiceZEndBuilder();
+ serviceZEnd.setServiceFormat(input.getServiceZEnd().getServiceFormat())
+ .setServiceRate(input.getServiceZEnd().getServiceRate())
+ .setOtuServiceRate(input.getServiceAEnd().getOtuServiceRate()) // set otu and odu
+ .setOduServiceRate(input.getServiceZEnd().getOduServiceRate())
+ .setClli(input.getServiceZEnd().getClli())
+ .setNodeId(new NodeIdType(input.getServiceZEnd().getNodeId().getValue()).getValue())
+ .setTxDirection(new org.opendaylight.yang.gen.v1.http.org
+ .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.TxDirectionBuilder()
+ .setPort(input.getServiceZEnd().getTxDirection().getPort()).build())
+ .setRxDirection(new org.opendaylight.yang.gen.v1.http.org
+ .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.RxDirectionBuilder()
+ .setPort(input.getServiceZEnd().getRxDirection().getPort()).build());
+
+ serviceImplementationRequestInputBuilder
+ .setServiceAEnd(serviceAEnd.build())
+ .setServiceZEnd(serviceZEnd.build())
+ .setConnectionType(input.getConnectionType())
+ .setServiceHandlerHeader(
+ new ServiceHandlerHeaderBuilder().setRequestId(input.getSdncRequestHeader().getRequestId()).build());
+ org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.service.implementation
+ .request.input.PathDescriptionBuilder pathDescBuilder = new org.opendaylight.yang.gen.v1.http.org
+ .opendaylight.transportpce.renderer.rev200520.service.implementation.request.input
+ .PathDescriptionBuilder();
+ pathDescBuilder
+ .setAToZDirection(pathDescription.getAToZDirection())
+ .setZToADirection(pathDescription.getZToADirection());
+ serviceImplementationRequestInputBuilder.setPathDescription(pathDescBuilder.build());
+ return serviceImplementationRequestInputBuilder.build();
}
public static org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520
.ServiceDeleteInput createServiceDeleteInput(ServiceInput serviceInput) {
- return new ServiceDeleteInputBuilder()
- .setServiceName(serviceInput.getServiceName())
- .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
- .setRequestId(serviceInput.getSdncRequestHeader().getRequestId())
- .build())
- .build();
+ ServiceDeleteInputBuilder builder = new ServiceDeleteInputBuilder()
+ .setServiceName(serviceInput.getServiceName())
+ .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
+ .setRequestId(serviceInput.getSdncRequestHeader().getRequestId()).build());
+ return builder.build();
}
public static org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520
.ServiceDeleteInput createServiceDeleteInput(ServiceRerouteInput serviceRerouteinput, Services services) {
- return new ServiceDeleteInputBuilder()
- .setServiceName(serviceRerouteinput.getServiceName())
- .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
- .setRequestId(services.getSdncRequestHeader().getRequestId())
- .build())
- .build();
+ ServiceDeleteInputBuilder builder = new ServiceDeleteInputBuilder()
+ .setServiceName(serviceRerouteinput.getServiceName())
+ .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder().setRequestId(
+ services.getSdncRequestHeader().getRequestId()).build());
+ return builder.build();
}
public static org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520
.ServiceDeleteInput createServiceDeleteInput(ServiceRestorationInput serviceRestorationInput,
- Services services) {
- return new ServiceDeleteInputBuilder()
- .setServiceName(serviceRestorationInput.getServiceName())
- .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
- .setRequestId(services.getSdncRequestHeader().getRequestId())
- .build())
- .build();
+ Services services) {
+ ServiceDeleteInputBuilder builder = new ServiceDeleteInputBuilder()
+ .setServiceName(serviceRestorationInput.getServiceName())
+ .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder().setRequestId(
+ services.getSdncRequestHeader().getRequestId()).build());
+ return builder.build();
}
public static org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev200520.ServiceDeleteInput
createServiceDeleteInput(ServiceReconfigureInput serviceReconfigureInput) {
- return new ServiceDeleteInputBuilder()
- .setServiceName(serviceReconfigureInput.getServiceName())
- .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
- .setRequestId(serviceReconfigureInput.getServiceName() + "-reconfigure")
- .build())
- .build();
+ String serviceName = serviceReconfigureInput.getServiceName();
+ ServiceDeleteInputBuilder builder = new ServiceDeleteInputBuilder()
+ .setServiceName(serviceReconfigureInput.getServiceName())
+ .setServiceHandlerHeader(
+ new ServiceHandlerHeaderBuilder().setRequestId(serviceName + "-reconfigure").build());
+ return builder.build();
}
- public static ServiceAEnd createServiceAEnd(org.opendaylight.yang.gen.v1.http
- .org.openroadm.common.service.types.rev190531.ServiceEndpoint serviceAEnd) {
- return new ServiceAEndBuilder()
- .setClli(serviceAEnd.getClli())
- .setNodeId(serviceAEnd.getNodeId().getValue())
- .setRxDirection(createRxDirection(serviceAEnd.getRxDirection()))
- .setServiceFormat(serviceAEnd.getServiceFormat())
- .setServiceRate(serviceAEnd.getServiceRate())
- .setTxDirection(createTxDirection(serviceAEnd.getTxDirection()))
- .build();
+ public static ServiceAEnd createServiceAEnd(org.opendaylight.yang.gen.v1
+ .http.org.openroadm.common.service.types.rev190531.ServiceEndpoint serviceAEnd) {
+ ServiceAEndBuilder serviceAEndBuilder = new ServiceAEndBuilder()
+ .setClli(serviceAEnd.getClli())
+ .setNodeId(serviceAEnd.getNodeId().getValue())
+ .setRxDirection(createRxDirection(serviceAEnd.getRxDirection()))
+ .setServiceFormat(serviceAEnd.getServiceFormat())
+ .setServiceRate(serviceAEnd.getServiceRate())
+ .setTxDirection(createTxDirection(serviceAEnd.getTxDirection()));
+ return serviceAEndBuilder.build();
}
- public static ServiceZEnd createServiceZEnd(org.opendaylight.yang.gen.v1.http
- .org.openroadm.common.service.types.rev190531.ServiceEndpoint serviceZEnd) {
- return new ServiceZEndBuilder()
- .setClli(serviceZEnd.getClli())
- .setNodeId(serviceZEnd.getNodeId().getValue())
- .setRxDirection(createRxDirection(serviceZEnd.getRxDirection()))
- .setServiceFormat(serviceZEnd.getServiceFormat())
- .setServiceRate(serviceZEnd.getServiceRate())
- .setTxDirection(createTxDirection(serviceZEnd.getTxDirection()))
- .build();
+ public static ServiceZEnd createServiceZEnd(org.opendaylight.yang.gen.v1
+ .http.org.openroadm.common.service.types.rev190531.ServiceEndpoint serviceZEnd) {
+ ServiceZEndBuilder serviceZEndBuilder = new ServiceZEndBuilder()
+ .setClli(serviceZEnd.getClli())
+ .setNodeId(serviceZEnd.getNodeId().getValue())
+ .setRxDirection(createRxDirection(serviceZEnd.getRxDirection()))
+ .setServiceFormat(serviceZEnd.getServiceFormat())
+ .setServiceRate(serviceZEnd.getServiceRate())
+ .setTxDirection(createTxDirection(serviceZEnd.getTxDirection()));
+ return serviceZEndBuilder.build();
}
- public static RxDirection createRxDirection(org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types
- .rev190531.service.endpoint.RxDirection rxDirection) {
- return new RxDirectionBuilder()
- .setPort(rxDirection.getPort())
- .build();
+ public static RxDirection createRxDirection(org.opendaylight.yang.gen.v1
+ .http.org.openroadm.common.service.types.rev190531.service.endpoint.RxDirection rxDirection) {
+ RxDirectionBuilder rxDirectionBuilder = new RxDirectionBuilder().setPort(rxDirection.getPort());
+ return rxDirectionBuilder.build();
}
- public static TxDirection createTxDirection(org.opendaylight.yang.gen.v1.http.org.openroadm.common.service
- .types.rev190531.service.endpoint.TxDirection txDirection) {
- return new TxDirectionBuilder()
- .setPort(txDirection.getPort())
- .build();
+ public static TxDirection createTxDirection(org.opendaylight.yang.gen.v1
+ .http.org.openroadm.common.service.types.rev190531.service.endpoint.TxDirection txDirection) {
+ TxDirectionBuilder txDirectionBuilder = new TxDirectionBuilder().setPort(txDirection.getPort());
+ return txDirectionBuilder.build();
}
public static ListenableFuture<RpcResult<ServiceDeleteOutput>> createDeleteServiceReply(ServiceDeleteInput input,
String finalAck, String message, String responseCode) {
- LOG.debug("createDeleteServiceReply : {}", message);
ConfigurationResponseCommonBuilder builder = new ConfigurationResponseCommonBuilder()
- .setAckFinalIndicator(finalAck)
- .setResponseMessage(message)
- .setResponseCode(responseCode);
+ .setAckFinalIndicator(finalAck).setResponseMessage(message).setResponseCode(responseCode);
if (input.getSdncRequestHeader() != null) {
builder.setRequestId(input.getSdncRequestHeader().getRequestId());
} else {
builder.setRequestId(null);
}
ConfigurationResponseCommon configurationResponseCommon = builder.build();
- ServiceDeleteOutput output = new ServiceDeleteOutputBuilder()
- .setConfigurationResponseCommon(configurationResponseCommon)
- .build();
+ ServiceDeleteOutput output =
+ new ServiceDeleteOutputBuilder().setConfigurationResponseCommon(configurationResponseCommon).build();
return RpcResultBuilder.success(output).buildFuture();
}
public static ListenableFuture<RpcResult<TempServiceDeleteOutput>> createDeleteServiceReply(
TempServiceDeleteInput input, String finalAck, String message, String responseCode) {
- LOG.debug("createDeleteServiceReply : {}", message);
- ConfigurationResponseCommonBuilder configurationResponseCommon =
- new ConfigurationResponseCommonBuilder()
- .setAckFinalIndicator(finalAck)
- .setResponseMessage(message)
- .setResponseCode(responseCode)
- .setRequestId(null);
+ ConfigurationResponseCommonBuilder builder = new ConfigurationResponseCommonBuilder()
+ .setAckFinalIndicator(finalAck)
+ .setResponseMessage(message)
+ .setResponseCode(responseCode)
+ .setRequestId(null);
+ ConfigurationResponseCommon configurationResponseCommon = builder.build();
TempServiceDeleteOutput output = new TempServiceDeleteOutputBuilder()
- .setConfigurationResponseCommon(configurationResponseCommon.build())
- .build();
+ .setConfigurationResponseCommon(configurationResponseCommon).build();
return RpcResultBuilder.success(output).buildFuture();
}
public static ListenableFuture<RpcResult<ServiceCreateOutput>> createCreateServiceReply(ServiceCreateInput input,
String finalAck, String message, String responseCode) {
- LOG.debug("createCreateServiceReply : {}", message);
ResponseParametersBuilder responseParameters = new ResponseParametersBuilder();
ConfigurationResponseCommonBuilder configurationResponseCommon = new ConfigurationResponseCommonBuilder()
- .setAckFinalIndicator(finalAck)
- .setResponseMessage(message)
- .setResponseCode(responseCode);
+ .setAckFinalIndicator(finalAck).setResponseMessage(message).setResponseCode(responseCode);
if (input.getSdncRequestHeader() != null) {
configurationResponseCommon.setRequestId(input.getSdncRequestHeader().getRequestId());
} else {
configurationResponseCommon.setRequestId(null);
}
- ServiceCreateOutputBuilder output = new ServiceCreateOutputBuilder()
- .setConfigurationResponseCommon(configurationResponseCommon.build())
+ ServiceCreateOutputBuilder output =
+ new ServiceCreateOutputBuilder().setConfigurationResponseCommon(configurationResponseCommon.build())
.setResponseParameters(responseParameters.build());
return RpcResultBuilder.success(output.build()).buildFuture();
}
public static ListenableFuture<RpcResult<TempServiceCreateOutput>> createCreateServiceReply(
TempServiceCreateInput input, String finalAck, String message, String responseCode) {
- LOG.debug("createCreateServiceReply : {}", message);
- ConfigurationResponseCommonBuilder configurationResponseCommon =
- new ConfigurationResponseCommonBuilder()
- .setAckFinalIndicator(finalAck)
- .setResponseMessage(message)
- .setResponseCode(responseCode);
+ ResponseParametersBuilder responseParameters = new ResponseParametersBuilder();
+ ConfigurationResponseCommonBuilder configurationResponseCommon = new ConfigurationResponseCommonBuilder()
+ .setAckFinalIndicator(finalAck).setResponseMessage(message).setResponseCode(responseCode);
if (input.getSdncRequestHeader() != null) {
configurationResponseCommon.setRequestId(input.getSdncRequestHeader().getRequestId());
} else {
configurationResponseCommon.setRequestId(null);
}
- TempServiceCreateOutputBuilder output = new TempServiceCreateOutputBuilder()
- .setConfigurationResponseCommon(configurationResponseCommon.build())
- .setResponseParameters(new ResponseParametersBuilder().build());
+ TempServiceCreateOutputBuilder output =
+ new TempServiceCreateOutputBuilder().setConfigurationResponseCommon(configurationResponseCommon.build())
+ .setResponseParameters(responseParameters.build());
return RpcResultBuilder.success(output.build()).buildFuture();
}
public static ListenableFuture<RpcResult<ServiceFeasibilityCheckOutput>> createCreateServiceReply(
ServiceFeasibilityCheckInput input, String finalAck, String message, String responseCode) {
- LOG.debug("createCreateServiceReply : {}", message);
ResponseParametersBuilder responseParameters = new ResponseParametersBuilder();
ConfigurationResponseCommonBuilder configurationResponseCommon = new ConfigurationResponseCommonBuilder()
- .setAckFinalIndicator(finalAck).setResponseMessage(message).setResponseCode(responseCode);
+ .setAckFinalIndicator(finalAck).setResponseMessage(message).setResponseCode(responseCode);
if (input.getSdncRequestHeader() != null) {
configurationResponseCommon.setRequestId(input.getSdncRequestHeader().getRequestId());
} else {
configurationResponseCommon.setRequestId(null);
}
ServiceFeasibilityCheckOutputBuilder output = new ServiceFeasibilityCheckOutputBuilder()
- .setConfigurationResponseCommon(configurationResponseCommon.build())
- .setResponseParameters(responseParameters.build());
+ .setConfigurationResponseCommon(configurationResponseCommon.build())
+ .setResponseParameters(responseParameters.build());
return RpcResultBuilder.success(output.build()).buildFuture();
}
public static ListenableFuture<RpcResult<ServiceReconfigureOutput>> createCreateServiceReply(
ServiceReconfigureInput input, String message, RpcStatus rpcStatus) {
- LOG.debug("createCreateServiceReply : {}", message);
ServiceReconfigureOutputBuilder output = new ServiceReconfigureOutputBuilder()
- .setStatus(rpcStatus)
- .setStatusMessage(message);
+ .setStatus(rpcStatus)
+ .setStatusMessage(message);
return RpcResultBuilder.success(output.build()).buildFuture();
}
public static ListenableFuture<RpcResult<ServiceRerouteOutput>> createRerouteServiceReply(ServiceRerouteInput input,
String finalAckYes, String message, RpcStatus status) {
- LOG.debug("createRerouteServiceReply : {}", message);
ServiceRerouteOutputBuilder output = new ServiceRerouteOutputBuilder()
- .setHardConstraints(null)
- .setSoftConstraints(null)
- .setStatus(status)
- .setStatusMessage(message);
+ .setHardConstraints(null)
+ .setSoftConstraints(null)
+ .setStatus(status)
+ .setStatusMessage(message);
return RpcResultBuilder.success(output.build()).buildFuture();
}
public static ListenableFuture<RpcResult<ServiceRestorationOutput>> createRestoreServiceReply(String message,
RpcStatus status) {
- LOG.debug("createRestoreServiceReply : {}", message);
ServiceRestorationOutputBuilder output = new ServiceRestorationOutputBuilder()
- .setStatus(status)
- .setStatusMessage(message);
+ .setStatus(status)
+ .setStatusMessage(message);
return RpcResultBuilder.success(output.build()).buildFuture();
}
ServicesBuilder service = new ServicesBuilder();
if (serviceCreateInput != null) {
aend = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service
- .ServiceAEndBuilder(serviceCreateInput.getServiceAEnd()).build();
+ .ServiceAEndBuilder(serviceCreateInput.getServiceAEnd()).build();
zend = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service
- .ServiceZEndBuilder(serviceCreateInput.getServiceZEnd()).build();
+ .ServiceZEndBuilder(serviceCreateInput.getServiceZEnd()).build();
service.setServiceName(serviceCreateInput.getServiceName()).setAdministrativeState(AdminStates.OutOfService)
- .setOperationalState(State.OutOfService).setCommonId(serviceCreateInput.getCommonId())
- .setConnectionType(serviceCreateInput.getConnectionType())
- .setCustomer(serviceCreateInput.getCustomer())
- .setCustomerContact(serviceCreateInput.getCustomerContact())
- .setHardConstraints(serviceCreateInput.getHardConstraints())
- .setSoftConstraints(serviceCreateInput.getSoftConstraints())
- .setSdncRequestHeader(serviceCreateInput.getSdncRequestHeader())
- .setLifecycleState(LifecycleState.Planned).setServiceAEnd(aend).setServiceZEnd(zend);
+ .setOperationalState(State.OutOfService).setCommonId(serviceCreateInput.getCommonId())
+ .setConnectionType(serviceCreateInput.getConnectionType())
+ .setCustomer(serviceCreateInput.getCustomer())
+ .setCustomerContact(serviceCreateInput.getCustomerContact())
+ .setHardConstraints(serviceCreateInput.getHardConstraints())
+ .setSoftConstraints(serviceCreateInput.getSoftConstraints())
+ .setSdncRequestHeader(serviceCreateInput.getSdncRequestHeader())
+ .setLifecycleState(LifecycleState.Planned).setServiceAEnd(aend).setServiceZEnd(zend);
} else if (serviceReconfigureInput != null) {
aend = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service
- .ServiceAEndBuilder(serviceReconfigureInput.getServiceAEnd()).build();
+ .ServiceAEndBuilder(serviceReconfigureInput.getServiceAEnd()).build();
zend = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service
- .ServiceZEndBuilder(serviceReconfigureInput.getServiceZEnd()).build();
+ .ServiceZEndBuilder(serviceReconfigureInput.getServiceZEnd()).build();
service.setServiceName(serviceReconfigureInput.getServiceName())
- .setAdministrativeState(AdminStates.OutOfService)
- .setOperationalState(State.OutOfService).setCommonId(serviceReconfigureInput.getCommonId())
- .setConnectionType(serviceReconfigureInput.getConnectionType())
- .setCustomer(serviceReconfigureInput.getCustomer())
- .setCustomerContact(serviceReconfigureInput.getCustomerContact())
- .setHardConstraints(serviceReconfigureInput.getHardConstraints())
- .setSoftConstraints(serviceReconfigureInput.getSoftConstraints())
- .setLifecycleState(LifecycleState.Planned).setServiceAEnd(aend).setServiceZEnd(zend);
+ .setAdministrativeState(AdminStates.OutOfService)
+ .setOperationalState(State.OutOfService).setCommonId(serviceReconfigureInput.getCommonId())
+ .setConnectionType(serviceReconfigureInput.getConnectionType())
+ .setCustomer(serviceReconfigureInput.getCustomer())
+ .setCustomerContact(serviceReconfigureInput.getCustomerContact())
+ .setHardConstraints(serviceReconfigureInput.getHardConstraints())
+ .setSoftConstraints(serviceReconfigureInput.getSoftConstraints())
+ .setLifecycleState(LifecycleState.Planned).setServiceAEnd(aend).setServiceZEnd(zend);
}
return service.build();
}
- public static org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.temp.service.list
- .Services mappingServices(TempServiceCreateInput tempServiceCreateInput) {
+ public static org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.temp.service.list.Services
+ mappingServices(TempServiceCreateInput tempServiceCreateInput) {
org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.ServiceAEnd aend = null;
org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.ServiceZEnd zend = null;
org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.temp.service.list
.ServicesBuilder service = new org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.temp
- .service.list.ServicesBuilder();
+ .service.list.ServicesBuilder();
aend = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service
- .ServiceAEndBuilder(tempServiceCreateInput.getServiceAEnd()).build();
+ .ServiceAEndBuilder(tempServiceCreateInput.getServiceAEnd()).build();
zend = new org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service
- .ServiceZEndBuilder(tempServiceCreateInput.getServiceZEnd()).build();
+ .ServiceZEndBuilder(tempServiceCreateInput.getServiceZEnd()).build();
service.setServiceName(tempServiceCreateInput.getCommonId()).setAdministrativeState(AdminStates.OutOfService)
- .setOperationalState(State.OutOfService).setCommonId(tempServiceCreateInput.getCommonId())
- .setConnectionType(tempServiceCreateInput.getConnectionType())
- .setCustomer(tempServiceCreateInput.getCustomer())
- .setCustomerContact(tempServiceCreateInput.getCustomerContact())
- .setHardConstraints(tempServiceCreateInput.getHardConstraints())
- .setSoftConstraints(tempServiceCreateInput.getSoftConstraints())
- .setSdncRequestHeader(tempServiceCreateInput.getSdncRequestHeader())
- .setLifecycleState(LifecycleState.Planned).setServiceAEnd(aend).setServiceZEnd(zend);
+ .setOperationalState(State.OutOfService).setCommonId(tempServiceCreateInput.getCommonId())
+ .setConnectionType(tempServiceCreateInput.getConnectionType())
+ .setCustomer(tempServiceCreateInput.getCustomer())
+ .setCustomerContact(tempServiceCreateInput.getCustomerContact())
+ .setHardConstraints(tempServiceCreateInput.getHardConstraints())
+ .setSoftConstraints(tempServiceCreateInput.getSoftConstraints())
+ .setSdncRequestHeader(tempServiceCreateInput.getSdncRequestHeader())
+ .setLifecycleState(LifecycleState.Planned).setServiceAEnd(aend).setServiceZEnd(zend);
return service.build();
}
public static ServicePaths mappingServicePaths(ServiceInput serviceInput, PathComputationRequestOutput output) {
- if (serviceInput == null) {
- return new ServicePathsBuilder().build();
- }
-
- org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128
+ ServicePathsBuilder servicePathBuilder = new ServicePathsBuilder();
+ if (serviceInput != null) {
+ org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128
.service.path.ServiceAEndBuilder serviceAEnd =
- new org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128
- .service.path.ServiceAEndBuilder()
- .setServiceFormat(serviceInput.getServiceAEnd().getServiceFormat())
- .setServiceRate(serviceInput.getServiceAEnd().getServiceRate())
- .setClli(serviceInput.getServiceAEnd().getClli())
- .setNodeId(new NodeIdType(serviceInput.getServiceAEnd().getNodeId()).getValue())
- .setTxDirection(new org.opendaylight.yang.gen.v1.http.org
- .transportpce.b.c._interface.service.types.rev200128
- .service.endpoint.sp.TxDirectionBuilder()
- .setPort(serviceInput.getServiceAEnd().getTxDirection().getPort())
- .build())
- .setRxDirection(new org.opendaylight.yang.gen.v1.http.org
- .transportpce.b.c._interface.service.types.rev200128
- .service.endpoint.sp.RxDirectionBuilder()
- .setPort(serviceInput.getServiceAEnd().getRxDirection().getPort())
- .build());
- org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128
+ new org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128
+ .service.path.ServiceAEndBuilder();
+ serviceAEnd.setServiceFormat(serviceInput.getServiceAEnd().getServiceFormat())
+ .setServiceRate(serviceInput.getServiceAEnd().getServiceRate())
+ .setClli(serviceInput.getServiceAEnd().getClli())
+ .setNodeId(new NodeIdType(serviceInput.getServiceAEnd().getNodeId()).getValue())
+ .setTxDirection(new org.opendaylight.yang.gen.v1.http.org
+ .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.TxDirectionBuilder()
+ .setPort(serviceInput.getServiceAEnd().getTxDirection().getPort()).build())
+ .setRxDirection(new org.opendaylight.yang.gen.v1.http.org
+ .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.RxDirectionBuilder()
+ .setPort(serviceInput.getServiceAEnd().getRxDirection().getPort()).build());
+ org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128
.service.path.ServiceZEndBuilder serviceZEnd =
- new org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128
- .service.path.ServiceZEndBuilder()
- .setServiceFormat(serviceInput.getServiceZEnd().getServiceFormat())
- .setServiceRate(serviceInput.getServiceZEnd().getServiceRate())
- .setClli(serviceInput.getServiceZEnd().getClli())
- .setNodeId(new NodeIdType(serviceInput.getServiceZEnd().getNodeId()).getValue())
- .setTxDirection(new org.opendaylight.yang.gen.v1.http.org
- .transportpce.b.c._interface.service.types.rev200128
- .service.endpoint.sp.TxDirectionBuilder()
- .setPort(serviceInput.getServiceZEnd().getTxDirection().getPort())
- .build())
- .setRxDirection(new org.opendaylight.yang.gen.v1.http.org
- .transportpce.b.c._interface.service.types.rev200128
- .service.endpoint.sp.RxDirectionBuilder()
- .setPort(serviceInput.getServiceZEnd().getRxDirection().getPort())
- .build());
- ServicePathsBuilder servicePathBuilder = new ServicePathsBuilder()
- .setServiceAEnd(serviceAEnd.build())
- .setServiceZEnd(serviceZEnd.build());
- MappingConstraints mapConstraints = new MappingConstraints(
- serviceInput.getHardConstraints(),
- serviceInput.getSoftConstraints()
- );
- mapConstraints.serviceToServicePathConstarints();
- if (mapConstraints.getServicePathHardConstraints() != null) {
- servicePathBuilder.setHardConstraints(
- new HardConstraintsBuilder()
+ new org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128
+ .service.path.ServiceZEndBuilder();
+ serviceZEnd.setServiceFormat(serviceInput.getServiceZEnd().getServiceFormat())
+ .setServiceRate(serviceInput.getServiceZEnd().getServiceRate())
+ .setClli(serviceInput.getServiceZEnd().getClli())
+ .setNodeId(new NodeIdType(serviceInput.getServiceZEnd().getNodeId()).getValue())
+ .setTxDirection(new org.opendaylight.yang.gen.v1.http.org
+ .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.TxDirectionBuilder()
+ .setPort(serviceInput.getServiceZEnd().getTxDirection().getPort()).build())
+ .setRxDirection(new org.opendaylight.yang.gen.v1.http.org
+ .transportpce.b.c._interface.service.types.rev200128.service.endpoint.sp.RxDirectionBuilder()
+ .setPort(serviceInput.getServiceZEnd().getRxDirection().getPort()).build());
+ servicePathBuilder.setServiceAEnd(serviceAEnd.build());
+ servicePathBuilder.setServiceZEnd(serviceZEnd.build());
+ MappingConstraints mapConstraints = new MappingConstraints(serviceInput.getHardConstraints(),
+ serviceInput.getSoftConstraints());
+ mapConstraints.serviceToServicePathConstarints();
+ if (mapConstraints.getServicePathHardConstraints() != null) {
+ HardConstraintsBuilder hardConstraintBuilder = new HardConstraintsBuilder()
.setCustomerCode(serviceInput.getHardConstraints().getCustomerCode())
- .setCoRoutingOrGeneral(mapConstraints.getServicePathHardConstraints().getCoRoutingOrGeneral())
- .build()
- );
- }
- if (mapConstraints.getServicePathSoftConstraints() != null) {
- servicePathBuilder.setSoftConstraints(
- new SoftConstraintsBuilder()
+ .setCoRoutingOrGeneral(mapConstraints.getServicePathHardConstraints().getCoRoutingOrGeneral());
+ servicePathBuilder.setHardConstraints(hardConstraintBuilder.build());
+ }
+ if (mapConstraints.getServicePathSoftConstraints() != null) {
+ SoftConstraintsBuilder softConstraintBuilder = new SoftConstraintsBuilder()
.setCustomerCode(mapConstraints.getServicePathSoftConstraints().getCustomerCode())
- .setCoRoutingOrGeneral(mapConstraints.getServicePathSoftConstraints().getCoRoutingOrGeneral())
- .build()
- );
- }
- servicePathBuilder
- .setServicePathName(serviceInput.getServiceName())
- .setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
- .setRequestId(serviceInput.getSdncRequestHeader().getRequestId())
- .build());
- if (output.getResponseParameters().getPathDescription() != null) {
- servicePathBuilder.setPathDescription(
- new PathDescriptionBuilder(output.getResponseParameters().getPathDescription()).build()
- );
+ .setCoRoutingOrGeneral(mapConstraints.getServicePathSoftConstraints().getCoRoutingOrGeneral());
+ servicePathBuilder.setSoftConstraints(softConstraintBuilder.build());
+ }
+ servicePathBuilder.setServicePathName(serviceInput.getServiceName());
+ servicePathBuilder.setServiceHandlerHeader(new ServiceHandlerHeaderBuilder()
+ .setRequestId(serviceInput.getSdncRequestHeader().getRequestId()).build());
+ if (output.getResponseParameters().getPathDescription() != null) {
+ PathDescriptionBuilder pathDescBuilder =
+ new PathDescriptionBuilder(output.getResponseParameters().getPathDescription());
+ servicePathBuilder.setPathDescription(pathDescBuilder.build());
+ }
}
return servicePathBuilder.build();
}
+
+
+ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+ value = "PZLA_PREFER_ZERO_LENGTH_ARRAYS",
+ justification = "not relevant to return and zero length array as we need real pos")
+ public static int[] findTheLongestSubstring(String s1, String s2) {
+ if ((s1 == null) || (s2 == null)) {
+ return null;
+ }
+ int[][] dp = new int[s1.length() + 1][s2.length() + 1];
+ int maxLen = 0;
+ int endPos = 0;
+ for (int i = 1; i < dp.length; i++) {
+ for (int j = 1; j < dp[0].length; j++) {
+ char ch1 = s1.charAt(i - 1);
+ char ch2 = s2.charAt(j - 1);
+ if (ch1 == ch2) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ if (dp[i][j] >= maxLen) {
+ maxLen = dp[i][j];
+ endPos = i;
+ }
+ }
+ }
+ }
+ return new int[] { endPos - maxLen, endPos };
+ }
}
<argument ref="dataBroker"/>
</bean>
- <bean id="pceListerner" class="org.opendaylight.transportpce.servicehandler.listeners.PceListenerImpl">
+ <bean id="pceListener" class="org.opendaylight.transportpce.servicehandler.listeners.PceListenerImpl">
<argument ref="rendererServiceOperations" />
<argument ref="pathComputationService" />
<argument ref="notificationPublishService" />
<argument ref="serviceDatastoreOperation" />
</bean>
- <bean id="rendererListerner" class="org.opendaylight.transportpce.servicehandler.listeners.RendererListenerImpl">
+ <bean id="rendererListener" class="org.opendaylight.transportpce.servicehandler.listeners.RendererListenerImpl">
<argument ref="pathComputationService" />
<argument ref="notificationPublishService" />
</bean>
<argument ref="notificationPublishService" />
<argument ref="rendererServiceOperations" />
<argument ref="networkModelWavelengthService" />
- <argument ref="pceListerner" />
- <argument ref="rendererListerner" />
+ <argument ref="pceListener" />
+ <argument ref="rendererListener" />
</bean>
<bean id="provider"
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev171017.service.path.list.ServicePathsBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DateAndTime;
import org.opendaylight.yangtools.yang.common.RpcResult;
-
+import org.opendaylight.yangtools.yang.common.Uint32;
public class ModelMappingUtilsTest extends AbstractTest {
.setResponseCode(ResponseCodes.RESPONSE_OK).setResponseMessage("PCE calculation in progress").build();
ResponseParameters responseParameters = new ResponseParametersBuilder()
.setPathDescription(new PathDescriptionBuilder()
- .setAToZDirection(new AToZDirectionBuilder().setAToZWavelengthNumber(1L).setRate(1L).build())
- .setZToADirection(new ZToADirectionBuilder().setZToAWavelengthNumber(1L).setRate(1L).build()).build())
+ .setAToZDirection(new AToZDirectionBuilder().setAToZWavelengthNumber(Uint32.valueOf(1))
+ .setRate(Uint32.valueOf(1)).build())
+ .setZToADirection(new ZToADirectionBuilder().setZToAWavelengthNumber(Uint32.valueOf(1))
+ .setRate(Uint32.valueOf(1)).build()).build())
.build();
return new PathComputationRequestOutputBuilder().setConfigurationResponseCommon(configurationResponseCommon)
.setResponseParameters(responseParameters).build();
{'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
'logical-connection-point': 'XPDR1-NETWORK1', 'port-direction': 'bidirectional',
'connection-map-lcp': 'XPDR1-CLIENT1', 'port-qual': 'xpdr-network',
- 'lcp-hash-val': 'APdT8Jzj+EVC'},
+ 'lcp-hash-val': 'OSvMgUyP+mE='},
res['mapping'])
def test_11_xpdr_portmapping_NETWORK2(self):
{'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/2-PLUG-NET',
'logical-connection-point': 'XPDR1-NETWORK2', 'port-direction': 'bidirectional',
'connection-map-lcp': 'XPDR1-CLIENT3', 'port-qual': 'xpdr-network',
- 'lcp-hash-val': 'APdT8Jzj+EVB'},
+ 'lcp-hash-val': 'OSvMgUyP+mI='},
res['mapping'])
def test_12_xpdr_portmapping_CLIENT1(self):
'supporting-circuit-pack-name': '1/0/C1-PLUG-CLIENT',
'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
'connection-map-lcp': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-client',
- 'lcp-hash-val': 'UHyVf5o4TF0='},
+ 'lcp-hash-val': 'AO9UFkY/TLYw'},
res['mapping'])
def test_13_xpdr_portmapping_CLIENT2(self):
'supporting-circuit-pack-name': '1/0/C2-PLUG-CLIENT',
'logical-connection-point': 'XPDR1-CLIENT2', 'port-direction': 'bidirectional',
'port-qual': 'xpdr-client',
- 'lcp-hash-val': 'UHyVf5o4TF4='},
+ 'lcp-hash-val': 'AO9UFkY/TLYz'},
res['mapping'])
def test_14_xpdr_portmapping_CLIENT3(self):
'supporting-circuit-pack-name': '1/0/C3-PLUG-CLIENT',
'logical-connection-point': 'XPDR1-CLIENT3',
'connection-map-lcp': 'XPDR1-NETWORK2', 'port-direction': 'bidirectional',
- 'port-qual': 'xpdr-client', 'lcp-hash-val': 'UHyVf5o4TF8='},
+ 'port-qual': 'xpdr-client', 'lcp-hash-val': 'AO9UFkY/TLYy'},
res['mapping'])
def test_15_xpdr_portmapping_CLIENT4(self):
{'supporting-port': 'C4',
'supporting-circuit-pack-name': '1/0/C4-PLUG-CLIENT',
'logical-connection-point': 'XPDR1-CLIENT4', 'port-direction': 'bidirectional',
- 'port-qual': 'xpdr-client', 'lcp-hash-val': 'UHyVf5o4TFg='},
+ 'port-qual': 'xpdr-client', 'lcp-hash-val': 'AO9UFkY/TLY1'},
res['mapping'])
def test_16_xpdr_device_disconnection(self):
{'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
'logical-connection-point': 'XPDR1-NETWORK1', 'port-direction': 'bidirectional',
'connection-map-lcp': 'XPDR1-CLIENT1', 'port-qual': 'xpdr-network',
- 'lcp-hash-val': 'APdT8Jzj+EVC'},
+ 'lcp-hash-val': 'OSvMgUyP+mE='},
res['nodes'][0]['mapping'])
self.assertIn(
{'supporting-port': 'C1',
'supporting-circuit-pack-name': '1/0/C1-PLUG-CLIENT',
'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
'connection-map-lcp': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-client',
- 'lcp-hash-val': 'UHyVf5o4TF0='},
+ 'lcp-hash-val': 'AO9UFkY/TLYw'},
res['nodes'][0]['mapping'])
def test_05_service_path_create(self):
from common import test_utils
-def extract_a_from_b(a, b):
- return dict([(i, b[i]) for i in b.keys() if i in a.keys()])
-
-
class TransportPCEtesting(unittest.TestCase):
processes = None
'logical-connection-point': 'XPDR1-CLIENT1',
'port-direction': 'bidirectional',
'port-qual': 'xpdr-client',
- 'lcp-hash-val': 'AIg960BwzGKe'},
+ 'lcp-hash-val': 'FqlcrxV7p30='},
res['mapping'])
def test_03_get_portmapping_NETWORK1(self):
"port-qual": "xpdr-network",
"supporting-circuit-pack-name": "CP1-CFP0",
"xponder-type": "mpdr",
- 'lcp-hash-val': 'AM7VlW5NpPm3'},
+ 'lcp-hash-val': 'Swfw02qXGyI='},
res['mapping'])
def test_04_service_path_create_OCH_OTU4(self):
"port-qual": "xpdr-network",
"supporting-circuit-pack-name": "CP1-CFP0",
"xponder-type": "mpdr",
- "lcp-hash-val": "AM7VlW5NpPm3"},
+ "lcp-hash-val": "Swfw02qXGyI="},
res['mapping'])
def test_06_check_interface_och(self):
'type': 'org-openroadm-interfaces:opticalChannel',
'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
'''
- self.assertDictEqual(input_dict,
- extract_a_from_b(input_dict,
- res['interface'][0])
- )
+ self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
+ 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': 'CP1-CFP0',
+ 'type': 'org-openroadm-interfaces:opticalChannel',
+ 'supporting-port': 'CP1-CFP0-P1'
+ } ,**res['interface'][0]),
+ res['interface'][0])
+
self.assertDictEqual(
{u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
u'transmit-power': -5},
"GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- input_dict = {'name': 'XPDR1-NETWORK1-OTU',
- 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-CFP0',
- 'supporting-interface': 'XPDR1-NETWORK1-1',
- 'type': 'org-openroadm-interfaces:otnOtu',
- 'supporting-port': 'CP1-CFP0-P1'}
-
- # assertDictContainsSubset is deprecated
- '''
- self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-OTU', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-CFP0', 'supporting-interface': 'XPDR1-NETWORK1-1',
- 'type': 'org-openroadm-interfaces:otnOtu',
- 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
- '''
- self.assertDictEqual(input_dict, extract_a_from_b(input_dict,
- res['interface'][0])
- )
+ input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
+ 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': 'CP1-CFP0',
+ 'supporting-interface': 'XPDR1-NETWORK1-1',
+ 'type': 'org-openroadm-interfaces:otnOtu',
+ 'supporting-port': 'CP1-CFP0-P1'
+ }
+
+ input_dict_2 = {'tx-dapi': 'Swfw02qXGyI=',
+ 'expected-sapi': 'Swfw02qXGyI=',
+ 'tx-sapi': 'Swfw02qXGyI=',
+ 'expected-dapi': 'Swfw02qXGyI=',
+ 'rate': 'org-openroadm-otn-common-types:OTU4',
+ 'fec': 'scfec'
+ }
+
+ self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+ res['interface'][0])
- self.assertDictEqual(
- {u'rate': u'org-openroadm-otn-common-types:OTU4',
- u'fec': u'scfec'},
+ self.assertDictEqual(input_dict_2,
res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_08_otn_service_path_create_ODU4(self):
"supporting-circuit-pack-name": "CP1-CFP0",
"xponder-type": "mpdr",
"supporting-odu4": "XPDR1-NETWORK1-ODU4",
- "lcp-hash-val": "AM7VlW5NpPm3"
+ "lcp-hash-val": "Swfw02qXGyI="
},
res['mapping'])
input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
'rate': 'org-openroadm-otn-common-types:ODU4'}
- self.assertDictEqual(input_dict_1, extract_a_from_b(input_dict_1,
- res['interface'][0])
- )
- self.assertDictEqual(input_dict_2,
- extract_a_from_b(input_dict_2,
- res['interface'][0][
- 'org-openroadm-otn-odu-interfaces:odu'])
-
+ self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+ res['interface'][0])
+ self.assertDictEqual(dict(input_dict_2,
+ **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
+ ),
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
)
- '''
- self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-ODU4', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-CFP0', 'supporting-interface': 'XPDR1-NETWORK1-OTU',
- 'type': 'org-openroadm-interfaces:otnOdu',
- 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
- self.assertDictContainsSubset(
- {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
- 'rate': 'org-openroadm-otn-common-types:ODU4'},
- res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
- '''
self.assertDictEqual(
{u'payload-type': u'21', u'exp-payload-type': u'21'},
res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
'type': 'org-openroadm-interfaces:ethernetCsmacd',
'supporting-port': 'CP1-SFP4-P1'
}
-
- '''
- self.assertDictContainsSubset({'name': 'XPDR1-CLIENT1-ETHERNET10G', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-SFP4',
- 'type': 'org-openroadm-interfaces:ethernetCsmacd',
- 'supporting-port': 'CP1-SFP4-P1'}, res['interface'][0])
- '''
- self.assertDictEqual(input_dict, extract_a_from_b(input_dict,
- res['interface'][0])
- )
+ self.assertDictEqual(dict(input_dict, **res['interface'][0]),
+ res['interface'][0])
self.assertDictEqual(
{u'speed': 10000},
res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
'rate': 'org-openroadm-otn-common-types:ODU2e',
'monitoring-mode': 'terminated'}
- self.assertDictEqual(input_dict_1, extract_a_from_b(input_dict_1,
- res['interface'][0])
- )
- self.assertDictEqual(input_dict_2,
- extract_a_from_b(input_dict_2, res['interface'][0][
- 'org-openroadm-otn-odu-interfaces:odu'])
- )
-
- '''
- self.assertDictContainsSubset({'name': 'XPDR1-CLIENT1-ODU2e-service1', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-SFP4',
- 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
- 'type': 'org-openroadm-interfaces:otnOdu',
- 'supporting-port': 'CP1-SFP4-P1'}, res['interface'][0])
- self.assertDictContainsSubset({
- 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
- 'rate': 'org-openroadm-otn-common-types:ODU2e',
- 'monitoring-mode': 'terminated'}, res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
- '''
+ self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+ res['interface'][0])
+ self.assertDictEqual(dict(input_dict_2,
+ **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
self.assertDictEqual(
{u'payload-type': u'03', u'exp-payload-type': u'03'},
res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
input_dict_3 = {'trib-port-number': 1}
- self.assertDictEqual(input_dict_1, extract_a_from_b(input_dict_1,
- res['interface'][0])
- )
-
- self.assertDictEqual(input_dict_2,
- extract_a_from_b(input_dict_2,
- res['interface'][0][
- 'org-openroadm-otn-odu-interfaces:odu']
- ))
-
- self.assertDictEqual(input_dict_3,
- extract_a_from_b(input_dict_3,
- res['interface'][0][
- 'org-openroadm-otn-odu-interfaces:odu'][
- 'parent-odu-allocation']))
-
- '''
- self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-ODU2e-service1', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-CFP0',
- 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
- 'type': 'org-openroadm-interfaces:otnOdu',
- 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
- self.assertDictContainsSubset({
- 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
- 'rate': 'org-openroadm-otn-common-types:ODU2e',
- 'monitoring-mode': 'monitored'}, res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
- self.assertDictContainsSubset(
- {'trib-port-number': 1},
- res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
- '''
+ self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+ res['interface'][0])
+ self.assertDictEqual(dict(input_dict_2,
+ **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
+ self.assertDictEqual(dict(input_dict_3,
+ **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
+ 'parent-odu-allocation']),
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
+ 'parent-odu-allocation'])
self.assertIn(1,
res['interface'][0][
'org-openroadm-otn-odu-interfaces:odu'][
'direction': 'bidirectional'
}
- self.assertDictEqual(input_dict_1,
- extract_a_from_b(input_dict_1,
- res['odu-connection'][0]))
- '''
- self.assertDictContainsSubset({
- 'connection-name': 'XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1',
- 'direction': 'bidirectional'},
- res['odu-connection'][0])
- '''
+ self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
+ res['odu-connection'][0])
self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1'},
res['odu-connection'][0]['destination'])
self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-service1'},
'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
'logical-connection-point': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-network',
'port-direction': 'bidirectional', 'connection-map-lcp': 'XPDR1-CLIENT1',
- 'lcp-hash-val': 'e54EtOovlcE='},
+ 'lcp-hash-val': 'AMkDwQ7xTmRI'},
res['mapping'])
def test_12_xpdr_portmapping_NETWORK2(self):
'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/2-PLUG-NET',
'logical-connection-point': 'XPDR1-NETWORK2', 'port-direction': 'bidirectional',
'connection-map-lcp': 'XPDR1-CLIENT2', 'port-qual': 'xpdr-network',
- 'lcp-hash-val': 'e54EtOovlcI='},
+ 'lcp-hash-val': 'AMkDwQ7xTmRL'},
res['mapping'])
def test_13_xpdr_portmapping_CLIENT1(self):
'supporting-circuit-pack-name': '1/0/1-PLUG-CLIENT',
'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
'connection-map-lcp': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-client',
- 'lcp-hash-val': 'BIyxYXnFEFA='},
+ 'lcp-hash-val': 'AJUUr6I5fALj'},
res['mapping'])
def test_14_xpdr_portmapping_CLIENT2(self):
'supporting-circuit-pack-name': '1/0/2-PLUG-CLIENT',
'logical-connection-point': 'XPDR1-CLIENT2', 'port-direction': 'bidirectional',
'connection-map-lcp': 'XPDR1-NETWORK2', 'port-qual': 'xpdr-client',
- 'lcp-hash-val': 'BIyxYXnFEFM='},
+ 'lcp-hash-val': 'AJUUr6I5fALg'},
res['mapping'])
def test_15_xpdr_device_disconnection(self):
'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
'logical-connection-point': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-network',
'port-direction': 'bidirectional', 'connection-map-lcp': 'XPDR1-CLIENT1',
- 'lcp-hash-val': 'e54EtOovlcE='},
+ 'lcp-hash-val': 'AMkDwQ7xTmRI'},
res['nodes'][0]['mapping'])
self.assertIn(
{'supported-interface-capability': ['org-openroadm-port-types:if-100GE'],
'supporting-circuit-pack-name': '1/0/1-PLUG-CLIENT',
'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
'connection-map-lcp': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-client',
- 'lcp-hash-val': 'BIyxYXnFEFA='},
+ 'lcp-hash-val': 'AJUUr6I5fALj'},
res['nodes'][0]['mapping'])
def test_05_service_path_create(self):
}, **res['interface'][0]),
res['interface'][0]
)
- self.assertDictEqual(
- {u'rate': u'org-openroadm-otn-common-types:OTU4',
- u'fec': u'scfec'},
+ input_dict_2 = {'tx-sapi': 'AMkDwQ7xTmRI',
+ 'expected-dapi': 'AMkDwQ7xTmRI',
+ 'rate': 'org-openroadm-otn-common-types:OTU4',
+ 'fec': 'scfec'}
+ self.assertDictEqual(input_dict_2,
res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_13_service_path_create_xpdr_check(self):
Code Review / transportpce.git / commitdiff