import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
+import org.opendaylight.transportpce.networkmodel.service.NetworkModelService;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
import org.opendaylight.transportpce.renderer.provisiondevice.servicepath.ServiceListTopology;
import org.opendaylight.transportpce.renderer.provisiondevice.servicepath.ServicePathDirection;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102.ServiceNodelist;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102.service.nodelist.NodelistBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102.service.nodelist.NodelistKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.Mapping;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200429.network.nodes.Mapping;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.CreateOtsOmsInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.CreateOtsOmsOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.CreateOtsOmsOutputBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.Services;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.ServicesBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.ServicesKey;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.node.interfaces.NodeInterface;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.node.interfaces.NodeInterfaceBuilder;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.node.interfaces.NodeInterfaceKey;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.olm.renderer.input.Nodes;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.node.interfaces.NodeInterface;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.node.interfaces.NodeInterfaceBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.node.interfaces.NodeInterfaceKey;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.olm.renderer.input.Nodes;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev200129.OtnLinkType;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+
public class DeviceRendererServiceImpl implements DeviceRendererService {
+ private static final String ODU4 = "-ODU4";
private static final Logger LOG = LoggerFactory.getLogger(DeviceRendererServiceImpl.class);
private final DataBroker dataBroker;
private final DeviceTransactionManager deviceTransactionManager;
private final OpenRoadmInterfaces openRoadmInterfaces;
private final CrossConnect crossConnect;
private final PortMapping portMapping;
+ private final NetworkModelService networkModelService;
public DeviceRendererServiceImpl(DataBroker dataBroker, DeviceTransactionManager deviceTransactionManager,
OpenRoadmInterfaceFactory openRoadmInterfaceFactory, OpenRoadmInterfaces openRoadmInterfaces,
- CrossConnect crossConnect, PortMapping portMapping) {
+ CrossConnect crossConnect, PortMapping portMapping, NetworkModelService networkModelService) {
this.dataBroker = dataBroker;
this.deviceTransactionManager = deviceTransactionManager;
this.openRoadmInterfaceFactory = openRoadmInterfaceFactory;
this.openRoadmInterfaces = openRoadmInterfaces;
this.crossConnect = crossConnect;
this.portMapping = portMapping;
+ this.networkModelService = networkModelService;
}
@Override
ConcurrentLinkedQueue<String> results = new ConcurrentLinkedQueue<>();
Set<NodeInterface> nodeInterfaces = Sets.newConcurrentHashSet();
Set<String> nodesProvisioned = Sets.newConcurrentHashSet();
+ CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
ServiceListTopology topology = new ServiceListTopology();
AtomicBoolean success = new AtomicBoolean(true);
ForkJoinPool forkJoinPool = new ForkJoinPool();
+
ForkJoinTask forkJoinTask = forkJoinPool.submit(() -> nodes.parallelStream().forEach(node -> {
String nodeId = node.getNodeId();
+ // take the index of the node
+ int nodeIndex = nodes.indexOf(node);
LOG.info("Starting provisioning for node : {}", nodeId);
List<String> createdEthInterfaces = new ArrayList<>();
List<String> createdOtuInterfaces = new ArrayList<>();
Long waveNumber = input.getWaveNumber().toJava();
if ((destTp != null) && destTp.contains(StringConstants.NETWORK_TOKEN)) {
crossConnectFlag++;
- Mapping mapping = this.portMapping.getMapping(nodeId,destTp);
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
+ Nodes tgtNode = null;
+ if (nodeIndex + 1 == nodes.size()) {
+ // For the end node, tgtNode becomes the first node in the list
+ tgtNode = nodes.get(0);
+ } else {
+ tgtNode = nodes.get(nodeIndex + 1);
+ }
+ // tgtNode srcTp is null in this if cond
String supportingOtuInterface = this.openRoadmInterfaceFactory
- .createOpenRoadmOtu4Interface(nodeId, destTp, supportingOchInterface);
+ .createOpenRoadmOtu4Interface(nodeId, destTp, supportingOchInterface,
+ tgtNode.getNodeId(), tgtNode.getDestTp());
createdOtuInterfaces.add(supportingOtuInterface);
- if (mapping != null && mapping.getXponderType() != null
- && (mapping.getXponderType().getIntValue() == 3
- || mapping.getXponderType().getIntValue() == 2)) {
- createdOduInterfaces.add(this.openRoadmInterfaceFactory
- .createOpenRoadmOtnOdu4Interface(nodeId,destTp, supportingOtuInterface));
+ if (srcTp == null) {
+ otnNodesProvisioned.add(node);
} else {
createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(nodeId,
destTp, supportingOtuInterface));
if (success.get()) {
results.add("Roadm-connection successfully created for nodes: " + String.join(", ", nodesProvisioned));
}
- ServicePathOutputBuilder setServBldr = new ServicePathOutputBuilder()
- .setNodeInterface(new ArrayList<>(nodeInterfaces))
- .setSuccess(success.get())
- .setResult(String.join("\n", results));
// setting topology in the service list data store
try {
setTopologyForService(input.getServiceName(), topology.getTopology());
+ updateOtnTopology(otnNodesProvisioned, false);
} catch (InterruptedException | TimeoutException | ExecutionException e) {
LOG.warn("Failed to write topologies for service {}.", input.getServiceName(), e);
}
if (!alarmSuppressionNodeRemoval(input.getServiceName())) {
LOG.error("Alarm suppresion node removal failed!!!!");
}
+ ServicePathOutputBuilder setServBldr = new ServicePathOutputBuilder()
+ .setNodeInterface(new ArrayList<>(nodeInterfaces))
+ .setSuccess(success.get())
+ .setResult(String.join("\n", results));
return setServBldr.build();
}
private ConcurrentLinkedQueue<String> processErrorMessage(String message, ForkJoinPool forkJoinPool,
ConcurrentLinkedQueue<String> messages) {
- LOG.warn(message);
+ LOG.warn("Received error message {}", message);
messages.add(message);
forkJoinPool.shutdown();
return messages;
if (!alarmSuppressionNodeRegistration(input)) {
LOG.warn("Alarm suppresion node registraion failed!!!!");
}
+ CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask forkJoinTask = forkJoinPool.submit(() -> nodes.parallelStream().forEach(node -> {
List<String> interfacesToDelete = new LinkedList<>();
srcTp = node.getSrcTp();
} else {
srcTp = "";
+ otnNodesProvisioned.add(node);
}
// if the node is currently mounted then proceed.
if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
- if (destTp.contains(StringConstants.NETWORK_TOKEN)
- || srcTp.contains(StringConstants.CLIENT_TOKEN)
- || srcTp.contains(StringConstants.NETWORK_TOKEN)
- || destTp.contains(StringConstants.CLIENT_TOKEN)) {
- if (destTp.contains(StringConstants.NETWORK_TOKEN)) {
- try {
- if (this.openRoadmInterfaces.getInterface(nodeId, destTp + "-ODU").isPresent()) {
- interfacesToDelete.add(destTp + "-ODU");
- }
- if (this.openRoadmInterfaces.getInterface(nodeId, destTp + "-ODU4").isPresent()) {
- interfacesToDelete.add(destTp + "-ODU4");
- }
- }
- catch (OpenRoadmInterfaceException e) {
- LOG.error("impossible to get interface {} or {}", destTp + "-ODU", destTp + "-ODU4", e);
- }
- interfacesToDelete.add(destTp + "-OTU");
- interfacesToDelete.add(
- this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(destTp, waveNumber));
- }
- if (srcTp.contains(StringConstants.NETWORK_TOKEN)) {
- interfacesToDelete.add(srcTp + "-ODU");
- interfacesToDelete.add(srcTp + "-OTU");
- interfacesToDelete
- .add(this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(srcTp, waveNumber));
- }
- if (srcTp.contains(StringConstants.CLIENT_TOKEN)) {
- interfacesToDelete.add(srcTp + "-ETHERNET");
- }
- if (destTp.contains(StringConstants.CLIENT_TOKEN)) {
- interfacesToDelete.add(destTp + "-ETHERNET");
- }
- } else {
- String connectionNumber = srcTp + "-" + destTp + "-" + waveNumber;
- List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, false);
- connectionNumber = destTp + "-" + srcTp + "-" + waveNumber;
- if (intToDelete != null) {
- for (String interf : intToDelete) {
- if (!this.openRoadmInterfaceFactory.isUsedbyXc(nodeId, interf, connectionNumber,
- this.deviceTransactionManager)) {
- interfacesToDelete.add(interf);
- }
- }
- }
- }
+ interfacesToDelete.addAll(getInterfaces2delete(nodeId, srcTp, destTp, waveNumber));
} else {
String result = nodeId + " is not mounted on the controller";
results.add(result);
LOG.error("Error while deleting service paths!", e);
}
forkJoinPool.shutdown();
+ updateOtnTopology(otnNodesProvisioned, true);
if (!alarmSuppressionNodeRemoval(input.getServiceName())) {
LOG.error("Alarm suppresion node removal failed!!!!");
}
}
}
+ private List<String> getInterfaces2delete(
+ String nodeId, String srcTp, String destTp, Long waveNumber) {
+ List<String> interfacesToDelete = new LinkedList<>();
+ if (destTp.contains(StringConstants.NETWORK_TOKEN)
+ || srcTp.contains(StringConstants.CLIENT_TOKEN)
+ || srcTp.contains(StringConstants.NETWORK_TOKEN)
+ || destTp.contains(StringConstants.CLIENT_TOKEN)) {
+ if (destTp.contains(StringConstants.NETWORK_TOKEN)) {
+ try {
+ if (this.openRoadmInterfaces.getInterface(nodeId, destTp + "-ODU").isPresent()) {
+ interfacesToDelete.add(destTp + "-ODU");
+ }
+ if (this.openRoadmInterfaces.getInterface(nodeId, destTp + ODU4).isPresent()) {
+ interfacesToDelete.add(destTp + ODU4);
+ }
+ }
+ catch (OpenRoadmInterfaceException e) {
+ LOG.error("impossible to get interface {} or {}", destTp + "-ODU", destTp + ODU4, e);
+ }
+ interfacesToDelete.add(destTp + "-OTU");
+ interfacesToDelete.add(
+ this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(destTp, waveNumber));
+ }
+ if (srcTp.contains(StringConstants.NETWORK_TOKEN)) {
+ interfacesToDelete.add(srcTp + "-ODU");
+ interfacesToDelete.add(srcTp + "-OTU");
+ interfacesToDelete
+ .add(this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(srcTp, waveNumber));
+ }
+ if (srcTp.contains(StringConstants.CLIENT_TOKEN)) {
+ interfacesToDelete.add(srcTp + "-ETHERNET");
+ }
+ if (destTp.contains(StringConstants.CLIENT_TOKEN)) {
+ interfacesToDelete.add(destTp + "-ETHERNET");
+ }
+ } else {
+ String connectionNumber = srcTp + "-" + destTp + "-" + waveNumber;
+ List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, false);
+ connectionNumber = destTp + "-" + srcTp + "-" + waveNumber;
+ if (intToDelete != null) {
+ for (String interf : intToDelete) {
+ if (!this.openRoadmInterfaceFactory.isUsedByXc(nodeId, interf, connectionNumber,
+ this.deviceTransactionManager)) {
+ interfacesToDelete.add(interf);
+ }
+ }
+ }
+ }
+ return interfacesToDelete;
+ }
+
@Override
public RendererRollbackOutput rendererRollback(RendererRollbackInput input) {
boolean success = true;
}
} else {
result = input.getNodeId() + " is not mounted on the controller";
- LOG.warn(result);
+ LOG.warn("{} is not mounted on the controller",input.getNodeId());
}
return output.setResult(result).setSuccess(success).build();
}
}
return result;
}
+
+ private void updateOtnTopology(CopyOnWriteArrayList<Nodes> nodes, boolean isDeletion) {
+ if (nodes.size() != 2) {
+ LOG.error("Error with OTU4 links to update in otn-topology");
+ return;
+ }
+ if (isDeletion) {
+ LOG.info("updating otn-topology removing OTU4 links");
+ this.networkModelService.deleteOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getDestTp(),
+ nodes.get(1).getNodeId(), nodes.get(1).getDestTp(), OtnLinkType.OTU4);
+ } else {
+ LOG.info("updating otn-topology adding OTU4 links");
+ this.networkModelService.createOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getDestTp(),
+ nodes.get(1).getNodeId(), nodes.get(1).getDestTp(), OtnLinkType.OTU4);
+ }
+ }
}
Code Review / transportpce.git / blobdiff