}
rpc service-path{
input{
+ leaf service-name{
+ type string;
+ }
leaf wave-number{
type uint32;
}
+ leaf modulation-format {
+ type string;
+ }
leaf operation{
type enumeration{
enum "create"{
--- /dev/null
+/*
+ * Copyright © 2017 AT&T and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.transportpce.renderer.openroadminterface;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.EthAttributes.AutoNegotiation;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.EthAttributes.Duplex;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.EthAttributes.Fec;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.Interface1;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.Interface1Builder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.ethernet.container.EthernetBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.EthernetCsmacd;
+
+public class OpenRoadmEthIterface extends OpenRoadmInterfaces {
+
+ public OpenRoadmEthIterface(DataBroker db, MountPointService mps, String nodeId, String logicalConnPoint,
+ String serviceName) {
+ super(db, mps, nodeId, logicalConnPoint, serviceName);
+
+ }
+
+ public String createInterface() {
+ InterfaceBuilder ethInterfaceBldr = getIntfBuilder(portMap);
+ ethInterfaceBldr.setType(EthernetCsmacd.class);
+ ethInterfaceBldr.setName(logicalConnPoint + "-ETHERNET");
+ ethInterfaceBldr.setKey(new InterfaceKey(logicalConnPoint + "-ETHERNET"));
+
+ // Ethernet interface specific data
+ EthernetBuilder ethIfBuilder = new EthernetBuilder();
+ ethIfBuilder.setAutoNegotiation(AutoNegotiation.Enabled);
+ ethIfBuilder.setDuplex(Duplex.Full);
+ ethIfBuilder.setFec(Fec.Off);
+ ethIfBuilder.setSpeed(new Long(100000));
+ ethIfBuilder.setMtu(new Long(9000));
+
+ // Create Interface1 type object required for adding as augmentation
+ Interface1Builder ethIf1Builder = new Interface1Builder();
+ ethInterfaceBldr.addAugmentation(Interface1.class, ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
+
+ // Post interface on the device
+ if (postInterface(ethInterfaceBldr)) {
+ return ethInterfaceBldr.getName();
+ } else {
+ return null;
+ }
+
+ }
+
+}
protected final DataBroker db;
protected final DataBroker netconfNodeDataBroker;
protected final String nodeId;
+ protected final MountPointService mps;
protected final Mapping portMap;
protected final String logicalConnPoint;
+ private final String serviceName;
private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaces.class);
public OpenRoadmInterfaces(DataBroker db, MountPointService mps, String nodeId, String logicalConnPoint) {
this.db = db;
+ this.mps = mps;
this.logicalConnPoint = logicalConnPoint;
this.nodeId = nodeId;
- this.portMap = PortMapping.getMapping(nodeId, logicalConnPoint, db);
+ if (logicalConnPoint != null) {
+ this.portMap = PortMapping.getMapping(nodeId, logicalConnPoint, db);
+ } else {
+ this.portMap = null;
+ }
+ this.serviceName = null;
+ netconfNodeDataBroker = PortMapping.getDeviceDataBroker(nodeId, mps);
+ }
+
+ public OpenRoadmInterfaces(DataBroker db, MountPointService mps, String nodeId, String logicalConnPoint,
+ String serviceName) {
+ this.db = db;
+ this.mps = mps;
+ this.logicalConnPoint = logicalConnPoint;
+ this.nodeId = nodeId;
+ if (logicalConnPoint != null) {
+ this.portMap = PortMapping.getMapping(nodeId, logicalConnPoint, db);
+ } else {
+ this.portMap = null;
+ }
+ this.serviceName = serviceName;
netconfNodeDataBroker = PortMapping.getDeviceDataBroker(nodeId, mps);
}
/**
- * This methods creates a generic interface builder object to set the value
- * that are common irrespective of the interface type.
+ * This methods creates a generic interface builder object to set the value that
+ * are common irrespective of the interface type.
*
* @param portMap
- * Mapping object containing attributes required to create
- * interface on the device.
+ * Mapping object containing attributes required to create interface
+ * on the device.
*
* @return InterfaceBuilder object with the data.
*/
}
/**
- * This methods does an edit-config operation on the openROADM device in
- * order to create the given interface.
+ * This methods does an edit-config operation on the openROADM device in order
+ * to create the given interface.
*
* <p>
* Before posting the interface it checks if:
* @return Result of operation true/false based on success/failure.
*/
public boolean postInterface(InterfaceBuilder ifBuilder) {
-
String intf2Post = ifBuilder.getName();
Interface intf2PostCheck = getInterface(intf2Post);
if (intf2PostCheck != null) {
if (intf2PostCheck.getAdministrativeState() == AdminStates.InService) {
- LOG.info("Interface with same name in service already exists");
+ LOG.info("Interface with same name in service already exists on node " + nodeId);
return true;
}
}
// Post interface with its specific augmentation to the device
if (netconfNodeDataBroker != null) {
- InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
- Interface.class, new InterfaceKey(ifBuilder.getName()));
+ InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(Interface.class, new InterfaceKey(ifBuilder.getName()));
final WriteTransaction writeTransaction = netconfNodeDataBroker.newWriteOnlyTransaction();
writeTransaction.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, ifBuilder.build());
final CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
try {
submit.checkedGet();
- LOG.info("Successfully posted interface " + ifBuilder.getName());
+ LOG.info("Successfully posted interface " + ifBuilder.getName() + " on node " + nodeId);
return true;
} catch (TransactionCommitFailedException ex) {
- LOG.warn("Failed to post {} ", ifBuilder.getName(),ex);
+ LOG.warn("Failed to post {} ", ifBuilder.getName() + " on node " + nodeId, ex);
return false;
}
/**
* This private does a get on the interface subtree of the device with the
- * interface name as the key and return the class corresponding to the
- * interface type.
+ * interface name as the key and return the class corresponding to the interface
+ * type.
*
* @param interfaceName
* Name of the interface
public Interface getInterface(String interfaceName) {
ReadOnlyTransaction rtx = netconfNodeDataBroker.newReadOnlyTransaction();
- InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
- Interface.class, new InterfaceKey(interfaceName));
+ InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(Interface.class, new InterfaceKey(interfaceName));
try {
Optional<Interface> interfaceObject = rtx.read(LogicalDatastoreType.CONFIGURATION, interfacesIID).get();
if (interfaceObject.isPresent()) {
return interfaceObject.get();
} else {
- LOG.info("Interface subtree is not present for " + interfaceName);
+ LOG.info("Interface subtree is not present for " + interfaceName + " on node " + nodeId);
}
} catch (InterruptedException | ExecutionException ex) {
- LOG.info("Read failed on interface subtree for",ex);
+ LOG.info("Read failed on interface subtree for" + interfaceName + " on node " + nodeId, ex);
return null;
}
return null;
}
/**
- * This methods does an edit-config operation on the openROADM device in
- * order to delete the given interface.
+ * This methods does an edit-config operation on the openROADM device in order
+ * to delete the given interface.
*
* <p>
* Before deleting the method:
// post interface with updated admin state
if (postInterface(ifBuilder)) {
InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
- .child(Interface.class, new InterfaceKey(interfaceName));
+ .child(Interface.class, new InterfaceKey(interfaceName));
final WriteTransaction writeTransaction = netconfNodeDataBroker.newWriteOnlyTransaction();
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, interfacesIID);
final CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
try {
submit.checkedGet();
- LOG.info("Successfully deleted " + interfaceName);
+ LOG.info("Successfully deleted " + interfaceName + " on node " + nodeId);
return true;
} catch (TransactionCommitFailedException ex) {
- LOG.error("Failed to delete interface {} ", interfaceName, ex);
+ LOG.error("Failed to delete interface " + interfaceName + " on node " + nodeId);
return false;
}
} else {
- LOG.error("Error changing the state of interface " + interfaceName);
+ LOG.error("Error changing the state of interface " + interfaceName + " on node " + nodeId);
return false;
}
} else {
- LOG.info("Interface does not exist, cannot delete");
+ LOG.info("Interface does not exist, cannot delete on node " + nodeId);
return false;
}
} else {
- LOG.info("Device databroker not found");
+ LOG.info("Device databroker not found on node " + nodeId);
return false;
}
}
-}
\ No newline at end of file
+}
package org.opendaylight.transportpce.renderer.openroadminterface;
+import java.math.BigDecimal;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.PowerDBm;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpticalChannel;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1Builder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes.ModulationFormat;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.RateIdentity;
import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.och.container.OchBuilder;
public class OpenRoadmOchInterface extends OpenRoadmInterfaces {
- public OpenRoadmOchInterface(DataBroker db, MountPointService mps, String nodeId, String logicalConnPoint) {
- super(db, mps, nodeId, logicalConnPoint);
+ public OpenRoadmOchInterface(DataBroker db, MountPointService mps, String nodeId, String logicalConnPoint,
+ String serviceName) {
+ super(db, mps, nodeId, logicalConnPoint, serviceName);
}
/**
- * This methods creates an OCH interface on the given termination point.
+ * This methods creates an OCH interface on the given termination point on
+ * Roadm.
*
* @param waveNumber
* wavelength number of the OCH interface.
OchBuilder ocIfBuilder = new OchBuilder();
ocIfBuilder.setWavelengthNumber(waveNumber);
- //Add supporting OMS interface
- ochInterfaceBldr.setSupportingInterface(portMap.getSupportingOms());
+ // Add supporting OMS interface
+ if (portMap.getSupportingOms() != null) {
+ ochInterfaceBldr.setSupportingInterface(portMap.getSupportingOms());
+ }
+ // Create Interface1 type object required for adding as augmentation
+ Interface1Builder ochIf1Builder = new Interface1Builder();
+ ochInterfaceBldr.addAugmentation(Interface1.class, ochIf1Builder.setOch(ocIfBuilder.build()).build());
+
+ // Post interface on the device
+ if (postInterface(ochInterfaceBldr)) {
+ return ochInterfaceBldr.getName();
+ } else {
+ return null;
+ }
+ }
+
+ public String createInterface(Long waveNumber, Class<? extends RateIdentity> rate, ModulationFormat format) {
+
+ // Create generic interface
+ InterfaceBuilder ochInterfaceBldr = getIntfBuilder(portMap);
+ ochInterfaceBldr.setType(OpticalChannel.class);
+ ochInterfaceBldr.setName(logicalConnPoint + "-" + waveNumber);
+ ochInterfaceBldr.setKey(new InterfaceKey(logicalConnPoint + "-" + waveNumber));
+
+ // OCH interface specific data
+ OchBuilder ocIfBuilder = new OchBuilder();
+ ocIfBuilder.setWavelengthNumber(waveNumber);
+ ocIfBuilder.setModulationFormat(format);
+ ocIfBuilder.setRate(rate);
+ ocIfBuilder.setTransmitPower(new PowerDBm(new BigDecimal("-5")));
// Create Interface1 type object required for adding as augmentation
Interface1Builder ochIf1Builder = new Interface1Builder();
return null;
}
}
+
}
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OtnOdu;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1Builder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.ODU4;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.OduAttributes.MonitoringMode;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.odu.container.OduBuilder;
public class OpenRoadmOdu4Interface extends OpenRoadmInterfaces {
- public OpenRoadmOdu4Interface(DataBroker db, MountPointService mps, String nodeId, String logicalConnPoint) {
- super(db, mps, nodeId, logicalConnPoint);
+ public OpenRoadmOdu4Interface(DataBroker db, MountPointService mps, String nodeId, String logicalConnPoint,
+ String serviceName) {
+ super(db, mps, nodeId, logicalConnPoint, serviceName);
}
* @return Name of the interface if successful, otherwise return null.
*/
- public String createInterface() {
- // TODO:implement this method
- return null;
+ public String createInterface(String supportingOtuInterface) {
+
+ InterfaceBuilder oduInterfaceBldr = getIntfBuilder(portMap);
+ oduInterfaceBldr.setType(OtnOdu.class);
+ oduInterfaceBldr.setSupportingInterface(supportingOtuInterface);
+ oduInterfaceBldr.setName(logicalConnPoint + "-ODU");
+ oduInterfaceBldr.setKey(new InterfaceKey(logicalConnPoint + "-ODU"));
+
+ // ODU interface specific data
+ OduBuilder oduIfBuilder = new OduBuilder();
+ oduIfBuilder.setRate(ODU4.class);
+ oduIfBuilder.setMonitoringMode(MonitoringMode.Monitored);
+
+ // Create Interface1 type object required for adding as augmentation
+ Interface1Builder oduIf1Builder = new Interface1Builder();
+ oduInterfaceBldr.addAugmentation(Interface1.class, oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+
+ // Post interface on the device
+ if (postInterface(oduInterfaceBldr)) {
+ return oduInterfaceBldr.getName();
+ } else {
+ return null;
+ }
}
}
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OtnOtu;
+
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1Builder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.OTU4;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.OtuAttributes.Fec;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.otu.container.OtuBuilder;
public class OpenRoadmOtu4Interface extends OpenRoadmInterfaces {
- public OpenRoadmOtu4Interface(DataBroker db, MountPointService mps, String nodeId, String logicalConnPoint) {
- super(db, mps, nodeId, logicalConnPoint);
+ public OpenRoadmOtu4Interface(DataBroker db, MountPointService mps, String nodeId, String logicalConnPoint,
+ String serviceName) {
+ super(db, mps, nodeId, logicalConnPoint, serviceName);
}
* @return Name of the interface if successful, otherwise return null.
*/
- public String createInterface() {
- // TODO: Implement this method
- return null;
+ public String createInterface(String supportOchInterface) {
+ // Create generic interface
+ InterfaceBuilder otuInterfaceBldr = getIntfBuilder(portMap);
+ otuInterfaceBldr.setType(OtnOtu.class);
+ otuInterfaceBldr.setSupportingInterface(supportOchInterface);
+ otuInterfaceBldr.setName(logicalConnPoint + "-OTU");
+ otuInterfaceBldr.setKey(new InterfaceKey(logicalConnPoint + "-OTU"));
+
+ // OTU interface specific data
+ OtuBuilder otuIfBuilder = new OtuBuilder();
+ otuIfBuilder.setFec(Fec.Scfec);
+ otuIfBuilder.setRate(OTU4.class);
+
+ // Create Interface1 type object required for adding as augmentation
+ Interface1Builder otuIf1Builder = new Interface1Builder();
+ otuInterfaceBldr.addAugmentation(Interface1.class, otuIf1Builder.setOtu(otuIfBuilder.build()).build());
+
+ // Post interface on the device
+ if (postInterface(otuInterfaceBldr)) {
+ return otuInterfaceBldr.getName();
+ } else {
+ return null;
+ }
}
-
}
--- /dev/null
+/*
+ * Copyright © 2017 AT&T and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.transportpce.renderer.openroadminterface;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes.ModulationFormat;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.RateIdentity;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class OpenRoadmXponderInterface extends OpenRoadmInterfaces {
+
+ private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmXponderInterface.class);
+ private final String serviceName;
+
+ public OpenRoadmXponderInterface(DataBroker db, MountPointService mps, String nodeId, String logicalConnPoint,
+ String serviceName) {
+ super(db, mps, nodeId, logicalConnPoint,serviceName);
+ this.serviceName = serviceName;
+
+ }
+
+ public boolean createLineInterfaces(Long waveNumber, Class<? extends RateIdentity> rate, ModulationFormat format) {
+
+ String supportOchInterface = new OpenRoadmOchInterface(db, mps, nodeId, logicalConnPoint,serviceName)
+ .createInterface(waveNumber, rate, format);
+ String supportingOtuInterface;
+ String supportingOduInterface;
+
+ if (supportOchInterface != null) {
+ supportingOtuInterface = new OpenRoadmOtu4Interface(db, mps, nodeId, logicalConnPoint,serviceName)
+ .createInterface(supportOchInterface);
+ } else {
+ LOG.error("Unable to create OCH interface on the transponder");
+ return false;
+ }
+ if (supportingOtuInterface != null) {
+ supportingOduInterface = new OpenRoadmOdu4Interface(db, mps, nodeId, logicalConnPoint,serviceName)
+ .createInterface(supportingOtuInterface);
+ } else {
+ LOG.error("Unable to create OTU interface on the transponder");
+ return false;
+ }
+ if (supportingOduInterface != null) {
+ return true;
+ } else {
+ LOG.error("Unable to create ODU interface on the transponder");
+ return false;
+ }
+ }
+
+ public boolean createClientInterfaces() {
+
+ if (new OpenRoadmEthIterface(db, mps, nodeId, logicalConnPoint,serviceName).createInterface() != null) {
+ return true;
+ }
+ return false;
+ }
+}
import org.opendaylight.transportpce.renderer.mapping.PortMapping;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaces;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOchInterface;
+import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmXponderInterface;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes.ModulationFormat;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.R100G;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.RendererService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.ServicePathInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.ServicePathOutput;
*/
public ServicePathOutputBuilder setupServicePath(ServicePathInput input) {
+ String serviceName = input.getServiceName();
List<Nodes> nodes = input.getNodes();
ServicePathOutputBuilder setServBldr = new ServicePathOutputBuilder();
LOG.info(currentMountedDevice.toString());
+ int crossConnectFlag;
for (Nodes n : nodes) {
LOG.info("Starting provisioning for node : " + n.getNodeId());
+ crossConnectFlag = 0;
String nodeId = n.getNodeId();
// if the node is currently mounted then proceed
if (currentMountedDevice.contains(n.getNodeId())) {
String destTp = n.getDestTp();
Long waveNumber = input.getWaveNumber();
- String srcIf = new OpenRoadmOchInterface(db, mps, nodeId, srcTp).createInterface(waveNumber);
- // if source interface creation was successful then proceed
- // otherwise return.
- if (srcIf == null) {
- LOG.warn("Unable to create OCH interface on " + nodeId + " at " + srcTp);
- return setServBldr.setResult("Unable to create OCH interface on " + nodeId + " at " + srcTp);
+ if (destTp.contains("NETWORK")) {
+ crossConnectFlag++;
+ if (!new OpenRoadmXponderInterface(db, mps, nodeId, destTp, serviceName)
+ .createLineInterfaces(waveNumber, R100G.class, ModulationFormat.Qpsk)) {
+
+ return setServBldr.setResult("Unable to LINE interface on " + nodeId + " at " + destTp);
+ }
+ }
+ if (srcTp.contains("CLIENT")) {
+ crossConnectFlag++;
+ if (!new OpenRoadmXponderInterface(db, mps, nodeId, srcTp, serviceName).createClientInterfaces()) {
+ return setServBldr.setResult("Unable to Client interface on " + nodeId + " at " + srcTp);
+ }
}
- // if destination interface creation was then proceed otherwise
- // return.
- String dstIf = new OpenRoadmOchInterface(db, mps, nodeId, destTp).createInterface(waveNumber);
- if (dstIf == null) {
- LOG.warn("Unable to create OCH interface on " + nodeId + " at " + destTp);
- return setServBldr.setResult("Unable to create OCH interface on " + nodeId + " at " + destTp);
+ String srcIf;
+ String dstIf;
+ if (srcTp.contains("TTP") || srcTp.contains("PP")) {
+ srcIf = new OpenRoadmOchInterface(db, mps, nodeId, srcTp, serviceName).createInterface(waveNumber);
+ // if source interface creation was successful then proceed
+ // otherwise return.
+ if (srcIf == null) {
+ LOG.warn("Unable to create OCH interface on " + nodeId + " at " + srcTp);
+ return setServBldr.setResult("Unable to create OCH interface on " + nodeId + " at " + srcTp);
+ }
}
- LOG.info("Creating cross connect between source :" + srcTp + " destination " + destTp + " for node " + n
- .getNodeId());
- DataBroker netconfNodeDataBroker = PortMapping.getDeviceDataBroker(nodeId, mps);
- CrossConnect roadmConnections = new CrossConnect(netconfNodeDataBroker);
- if (roadmConnections.postCrossConnect(waveNumber, srcTp, destTp) == true) {
- nodesProvisioned.add(nodeId);
- roadmConnections.getConnectionPortTrail(nodeId, mps, waveNumber, srcTp, destTp);
-
- } else {
- return setServBldr.setResult("Unable to post Roadm-connection for node " + nodeId);
+ if (destTp.contains("TTP") || destTp.contains("PP")) {
+ dstIf = new OpenRoadmOchInterface(db, mps, nodeId, destTp, serviceName).createInterface(waveNumber);
+ // if destination interface creation was successful then proceed
+ // otherwise return.
+ if (dstIf == null) {
+ LOG.warn("Unable to create OCH interface on " + nodeId + " at " + destTp);
+ return setServBldr.setResult("Unable to create OCH interface on " + nodeId + " at " + destTp);
+ }
+ }
+ if (crossConnectFlag < 1) {
+ LOG.info("Creating cross connect between source :" + srcTp + " destination " + destTp + " for node "
+ + n.getNodeId());
+ DataBroker netconfNodeDataBroker = PortMapping.getDeviceDataBroker(nodeId, mps);
+ String crossConnectName = srcTp + "-" + destTp + "-" + waveNumber;
+ CrossConnect roadmConnections = new CrossConnect(netconfNodeDataBroker);
+ if (roadmConnections.postCrossConnect(waveNumber, srcTp, destTp) == true) {
+ nodesProvisioned.add(nodeId);
+ roadmConnections.getConnectionPortTrail(nodeId, mps, waveNumber, srcTp, destTp);
+ } else {
+ return setServBldr.setResult("Unable to post Roadm-connection for node " + nodeId);
+ }
}
} else {
LOG.warn(nodeId + " is not mounted on the controller");
return setServBldr.setResult("Roadm-connection successfully created for nodes " + nodesProvisioned.toString());
}
+
/**
* This method removes wavelength path based on following steps: For each
* node:
// if the node is currently mounted then proceed.
if (currentMountedDevice.contains(nodeId)) {
+
+ if (destTp.contains("NETWORK")) {
+ if (new OpenRoadmInterfaces(db, mps, nodeId, destTp)
+ .deleteInterface(destTp + "-ODU") == false) {
+ LOG.error("Failed to delete interface " + destTp + "-ODU");
+ }
+ if (new OpenRoadmInterfaces(db, mps, nodeId, destTp)
+ .deleteInterface(destTp + "-OTU") == false) {
+ LOG.error("Failed to delete interface " + destTp + "-OTU");
+ }
+ if (new OpenRoadmInterfaces(db, mps, nodeId, destTp)
+ .deleteInterface(destTp + "-" + waveNumber) == false) {
+ LOG.error("Failed to delete interface " + destTp + "-" + waveNumber);
+ }
+ }
+ if (srcTp.contains("CLIENT")) {
+ // Deleting interface on source termination point
+ if (new OpenRoadmInterfaces(db, mps, nodeId, srcTp)
+ .deleteInterface(srcTp + "-ETHERNET") == false) {
+ LOG.error("Failed to delete Ethernet interface on " + srcTp);
+ }
+ continue;
+ }
String connectionNumber = srcTp + "-" + destTp + "-" + waveNumber;
CrossConnect roadmConnection = new CrossConnect(PortMapping.getDeviceDataBroker(nodeId, mps),
- connectionNumber);
+ connectionNumber);
if (!roadmConnection.deleteCrossConnect()) {
LOG.error("Failed to delete {} ", srcTp + "-" + destTp + "-" + waveNumber);
}
// Deleting interface on source termination point
- if (new OpenRoadmInterfaces(db, mps, nodeId, srcTp).deleteInterface(srcTp + "-" + waveNumber
- .toString()) == false) {
+ if (new OpenRoadmInterfaces(db, mps, nodeId, srcTp)
+ .deleteInterface(srcTp + "-" + waveNumber.toString()) == false) {
LOG.error("Failed to delete interface " + srcTp + "-" + waveNumber.toString());
}
// Deleting interface on destination termination point
- if (new OpenRoadmInterfaces(db, mps, nodeId, srcTp).deleteInterface(destTp + "-" + waveNumber
- .toString()) == false) {
- LOG.error("Failed to delete interface " + srcTp + "-" + waveNumber.toString());
+ if (new OpenRoadmInterfaces(db, mps, nodeId, destTp)
+ .deleteInterface(destTp + "-" + waveNumber.toString()) == false) {
+ LOG.error("Failed to delete interface " + destTp + "-" + waveNumber.toString());
}
} else {
LOG.warn(nodeId + " is not mounted on the controller");
}
return delServBldr.setResult("Request processed");
}
-}
\ No newline at end of file
+}
Code Review / transportpce.git / commitdiff