case _121:
return StringConstants.OPENROADM_DEVICE_VERSION_1_2_1;
default:
- return StringConstants.OPENROADM_DEVICE_VERSION_1_2_1;
+ LOG.warn("unknown openROADM device version");
}
} else {
LOG.warn("Could not find mapping for nodeId {}", nodeId);
- return StringConstants.OPENROADM_DEVICE_VERSION_1_2_1;
}
} catch (InterruptedException | ExecutionException ex) {
LOG.error("Unable to read mapping for nodeId {}",nodeId, ex);
package org.opendaylight.transportpce.common.mapping;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.Nodes;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.Mapping;
public interface PortMapping {
*
* @return true/false based on status of operation
*/
- boolean createMappingData(String nodeId);
+ boolean createMappingData(String nodeId, String nodeVersion);
/**
* This method removes mapping data from the datastore after disconnecting
Mapping getMapping(String nodeId, String logicalConnPoint);
boolean updateMapping(String nodeId, Mapping mapping);
+
+ /**
+ * This method returns all Mapping informations already stored in the MD-SAL
+ * data store for a given openroadm device. Beyound the list of mappings, it
+ * gives access to general node information as its version or its node type,
+ * etc.
+ *
+ * @param nodeId
+ * Unique Identifier for the node of interest.
+ *
+ * @return node data if success otherwise null.
+ */
+ Nodes getNode(String nodeId);
}
}
@Override
- public boolean createMappingData(String nodeId) {
-
- String openROADMversion = mappingUtils.getOpenRoadmVersion(nodeId);
- if (openROADMversion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) {
+ public boolean createMappingData(String nodeId, String nodeVersion) {
+ if (nodeVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) {
return portMappingVersion121.createMappingData(nodeId);
}
- else if (openROADMversion.equals(OPENROADM_DEVICE_VERSION_2_2)) {
+ else if (nodeVersion.equals(OPENROADM_DEVICE_VERSION_2_2)) {
return portMappingVersion22.createMappingData(nodeId);
}
-
else {
return false;
}
}
}
+ @Override
+ public Nodes getNode(String nodeId) {
+ InstanceIdentifier<Nodes> nodePortMappingIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
+ new NodesKey(nodeId)).build();
+ try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+ Optional<Nodes> nodePortMapObject = readTx.read(LogicalDatastoreType.CONFIGURATION, nodePortMappingIID)
+ .get().toJavaUtil();
+ if (nodePortMapObject.isPresent()) {
+ Nodes node = nodePortMapObject.get();
+ LOG.info("Found node {} in portmapping.", nodeId);
+ return node;
+ } else {
+ LOG.warn("Could not find node {} in portmapping.", nodeId);
+ }
+ } catch (InterruptedException | ExecutionException ex) {
+ LOG.error("Unable to get node {} in portmapping", nodeId);
+ }
+ return null;
+ }
+
}
public boolean createMappingData(String nodeId) {
- LOG.info("Create Mapping Data for node {}", nodeId);
+ LOG.info("Create Mapping Data for node 1.2.1 {}", nodeId);
List<Mapping> portMapList = new ArrayList<>();
InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
Optional<Info> deviceInfoOptional = this.deviceTransactionManager.getDataFromDevice(nodeId,
public boolean createMappingData(String nodeId) {
- LOG.info("Create Mapping Data for node {}", nodeId);
+ LOG.info("Create Mapping Data for node 2.2 {}", nodeId);
List<Mapping> portMapList = new ArrayList<>();
InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
Optional<Info> deviceInfoOptional = this.deviceTransactionManager
continue;
}
for (Ports port : cp.getPorts()) {
- if (Port.PortQual.XpdrNetwork.equals(port.getPortQual())) {
+ if (Port.PortQual.XpdrNetwork.getName().equals(port.getPortQual().getName())) {
portMapList.add(createMappingObject(nodeId, port, circuitPackName,
"XPDR1-" + StringConstants.NETWORK_TOKEN + line));
line++;
- } else if (Port.PortQual.XpdrClient.equals(port.getPortQual())) {
+ } else if (Port.PortQual.XpdrClient.getName().equals(port.getPortQual().getName())) {
portMapList.add(createMappingObject(nodeId, port, circuitPackName,
"XPDR1-" + StringConstants.CLIENT_TOKEN + client));
client++;
} else {
- LOG.warn("Not supported type of port! Port type: {}", port.getPortQual());
+ LOG.warn("Not supported type of port! Port type: {}", port.getPortQual().getName());
}
}
}
InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter));
Optional<SharedRiskGroup> ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
- LogicalDatastoreType.CONFIGURATION, srgIID,
+ LogicalDatastoreType.OPERATIONAL, srgIID,
Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
if (ordmSrgObject.isPresent()) {
srgCps.addAll(ordmSrgObject.get().getCircuitPacks());
InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(Degree.class, new DegreeKey(degreeCounter));
Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
- LogicalDatastoreType.CONFIGURATION, deviceIID,
+ LogicalDatastoreType.OPERATIONAL, deviceIID,
Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
if (ordmDegreeObject.isPresent()) {
degrees.add(ordmDegreeObject.get());
NodesBuilder nodesBldr = new NodesBuilder();
nodesBldr.withKey(new NodesKey(deviceInfo.getNodeId().getValue())).setNodeId(deviceInfo.getNodeId().getValue());
nodesBldr.setNodeType(NodeTypes.forValue(nodeType));
- nodesBldr.setOpenroadmVersion(Nodes.OpenroadmVersion._121);
+ nodesBldr.setOpenroadmVersion(Nodes.OpenroadmVersion._22);
if (portMapList != null) {
nodesBldr.setMapping(portMapList);
}
package org.opendaylight.transportpce.networkmodel;
import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
import javax.annotation.Nonnull;
+
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.netconf.Streams;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
NetconfNodeConnectionStatus.ConnectionStatus connectionStatus =
netconfNode.getConnectionStatus();
try {
- long count = netconfNode.getAvailableCapabilities().getAvailableCapability().stream()
- .filter(cp -> cp.getCapability().contains(StringConstants.OPENROADM_DEVICE_MODEL_NAME))
- .count();
- if (count > 0) {
+ List<AvailableCapability> deviceCapabilities = netconfNode.getAvailableCapabilities()
+ .getAvailableCapability().stream().filter(cp -> cp.getCapability()
+ .contains(StringConstants.OPENROADM_DEVICE_MODEL_NAME)).collect(Collectors.toList());
+ if (!deviceCapabilities.isEmpty()) {
+ Collections.sort(deviceCapabilities, (cp0, cp1) -> cp1.getCapability()
+ .compareTo(cp0.getCapability()));
LOG.info("OpenROADM node detected: {} {}", nodeId, connectionStatus.name());
switch (connectionStatus) {
case Connected:
- this.networkModelService.createOpenROADMnode(nodeId);
+ this.networkModelService.createOpenROADMnode(nodeId, deviceCapabilities.get(0)
+ .getCapability());
onDeviceConnected(nodeId);
break;
case Connecting:
break;
}
}
+ LOG.error("Not an openROADM node");
} catch (NullPointerException e) {
LOG.error("Cannot get available Capabilities");
}
*
* @param nodeId
* unique node ID of new OpenROADM node
+ * @param nodeVersion
+ * OpenROADM node version
*/
- void createOpenROADMnode(String nodeId);
+ void createOpenROADMnode(String nodeId, String nodeVersion);
/**
* Delete OpenROADM node mapping and topologies.
}
@Override
- public void createOpenROADMnode(String nodeId) {
+ public void createOpenROADMnode(String nodeId, String nodeVersion) {
try {
LOG.info("createOpenROADMNode: {} ", nodeId);
- this.portMapping.createMappingData(nodeId);
- this.linkDiscovery.readLLDP(new NodeId(nodeId));
+ boolean isPortMapping = this.portMapping.createMappingData(nodeId, nodeVersion);
+ if (isPortMapping && "1.2.1".equals(this.portMapping.getNode(nodeId).getOpenroadmVersion().getName())) {
+ this.linkDiscovery.readLLDP(new NodeId(nodeId));
- Node clliNode = ClliNetwork.createNode(this.deviceTransactionManager, nodeId);
- if (clliNode == null) {
- LOG.error("Unable to create clli node! Node id: {}", nodeId);
- return;
- }
+ Node clliNode = ClliNetwork.createNode(this.deviceTransactionManager, nodeId);
+ if (clliNode == null) {
+ LOG.error("Unable to create clli node! Node id: {}", nodeId);
+ return;
+ }
- Node openRoadmNode = OpenRoadmNetwork.createNode(nodeId, this.deviceTransactionManager);
- if (openRoadmNode == null) {
- LOG.error("Unable to create OpenRoadm node! Node id: {}", nodeId);
- return;
- }
+ Node openRoadmNode = OpenRoadmNetwork.createNode(nodeId, this.deviceTransactionManager);
+ if (openRoadmNode == null) {
+ LOG.error("Unable to create OpenRoadm node! Node id: {}", nodeId);
+ return;
+ }
- TopologyShard topologyShard = this.openRoadmTopology.createTopologyShard(nodeId);
- if (topologyShard == null) {
- LOG.error("Unable to create topology shard for node {}!", nodeId);
- return;
- }
- this.topologyShardMountedDevice.put(nodeId, topologyShard);
+ TopologyShard topologyShard = this.openRoadmTopology.createTopologyShard(nodeId);
+ if (topologyShard == null) {
+ LOG.error("Unable to create topology shard for node {}!", nodeId);
+ return;
+ }
+ this.topologyShardMountedDevice.put(nodeId, topologyShard);
- WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
- LOG.info("creating node in {}", NetworkUtils.CLLI_NETWORK_ID);
- InstanceIdentifier<Node> iiClliNode = InstanceIdentifier
- .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.CLLI_NETWORK_ID)))
- .child(Node.class, clliNode.key())
- .build();
- writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiClliNode, clliNode,
- CREATE_MISSING_PARENTS);
- LOG.info("creating node in {}", NetworkUtils.UNDERLAY_NETWORK_ID);
- InstanceIdentifier<Node> iiOpenRoadmNode = InstanceIdentifier
- .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID)))
- .child(Node.class, openRoadmNode.key())
- .build();
- writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmNode, openRoadmNode,
- CREATE_MISSING_PARENTS);
- for (Node openRoadmTopologyNode: topologyShard.getNodes()) {
- LOG.info("creating node {} in {}", openRoadmTopologyNode.getNodeId().getValue(),
- NetworkUtils.OVERLAY_NETWORK_ID);
- InstanceIdentifier<Node> iiOpenRoadmTopologyNode = InstanceIdentifier
- .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
- .child(Node.class, openRoadmTopologyNode.key())
+ WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
+ LOG.info("creating node in {}", NetworkUtils.CLLI_NETWORK_ID);
+ InstanceIdentifier<Node> iiClliNode = InstanceIdentifier
+ .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.CLLI_NETWORK_ID)))
+ .child(Node.class, clliNode.key())
.build();
- writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyNode,
- openRoadmTopologyNode, CREATE_MISSING_PARENTS);
- }
- for (Link openRoadmTopologyLink: topologyShard.getLinks()) {
- LOG.info("creating link {} in {}", openRoadmTopologyLink.getLinkId().getValue(),
- NetworkUtils.OVERLAY_NETWORK_ID);
- InstanceIdentifier<Link> iiOpenRoadmTopologyLink = InstanceIdentifier
- .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
- .augmentation(Network1.class)
- .child(Link.class, openRoadmTopologyLink.key())
+ writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiClliNode, clliNode,
+ CREATE_MISSING_PARENTS);
+ LOG.info("creating node in {}", NetworkUtils.UNDERLAY_NETWORK_ID);
+ InstanceIdentifier<Node> iiOpenRoadmNode = InstanceIdentifier
+ .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID)))
+ .child(Node.class, openRoadmNode.key())
.build();
- writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyLink,
- openRoadmTopologyLink, CREATE_MISSING_PARENTS);
+ writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmNode, openRoadmNode,
+ CREATE_MISSING_PARENTS);
+ for (Node openRoadmTopologyNode: topologyShard.getNodes()) {
+ LOG.info("creating node {} in {}", openRoadmTopologyNode.getNodeId().getValue(),
+ NetworkUtils.OVERLAY_NETWORK_ID);
+ InstanceIdentifier<Node> iiOpenRoadmTopologyNode = InstanceIdentifier
+ .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
+ .child(Node.class, openRoadmTopologyNode.key())
+ .build();
+ writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyNode,
+ openRoadmTopologyNode, CREATE_MISSING_PARENTS);
+ }
+ for (Link openRoadmTopologyLink: topologyShard.getLinks()) {
+ LOG.info("creating link {} in {}", openRoadmTopologyLink.getLinkId().getValue(),
+ NetworkUtils.OVERLAY_NETWORK_ID);
+ InstanceIdentifier<Link> iiOpenRoadmTopologyLink = InstanceIdentifier
+ .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
+ .augmentation(Network1.class)
+ .child(Link.class, openRoadmTopologyLink.key())
+ .build();
+ writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyLink,
+ openRoadmTopologyLink, CREATE_MISSING_PARENTS);
+ }
+ writeTransaction.submit().get();
+ LOG.info("all nodes and links created");
+ } else {
+ LOG.warn("openroadm-topology is not managed yet with openROADM device 2.2");
}
- writeTransaction.submit().get();
- LOG.info("all nodes and links created");
} catch (InterruptedException | ExecutionException e) {
LOG.error("ERROR: ", e);
}
Code Review / transportpce.git / commitdiff