networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/service/NetworkModelServiceImpl.java

   1 /*
   2  * Copyright © 2016 AT&T and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.transportpce.networkmodel.service;
   9
  10 import java.util.HashMap;
  11 import java.util.concurrent.ExecutionException;
  12 import java.util.concurrent.TimeUnit;
  13 import java.util.concurrent.TimeoutException;
  14
  15 import org.eclipse.jdt.annotation.Nullable;
  16 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  17 import org.opendaylight.transportpce.common.NetworkUtils;
  18 import org.opendaylight.transportpce.common.mapping.PortMapping;
  19 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
  20 import org.opendaylight.transportpce.networkmodel.R2RLinkDiscovery;
  21 import org.opendaylight.transportpce.networkmodel.dto.TopologyShard;
  22 import org.opendaylight.transportpce.networkmodel.util.ClliNetwork;
  23 import org.opendaylight.transportpce.networkmodel.util.OpenRoadmNetwork;
  24 import org.opendaylight.transportpce.networkmodel.util.OpenRoadmOtnTopology;
  25 import org.opendaylight.transportpce.networkmodel.util.OpenRoadmTopology;
  26 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.NodeInfo;
  27 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.NodeInfo.OpenroadmVersion;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.NodeTypes;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
  39 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 public class NetworkModelServiceImpl implements NetworkModelService {
  44
  45     private static final Logger LOG = LoggerFactory.getLogger(NetworkModelServiceImpl.class);
  46     private static final boolean CREATE_MISSING_PARENTS = true;
  47
  48     private NetworkTransactionService networkTransactionService;
  49     private final R2RLinkDiscovery linkDiscovery;
  50     private final PortMapping portMapping;
  51     private HashMap<String,TopologyShard> topologyShardMountedDevice;
  52     private HashMap<String,TopologyShard> otnTopologyShardMountedDevice;
  53
  54     public NetworkModelServiceImpl(final NetworkTransactionService networkTransactionService,
  55         final R2RLinkDiscovery linkDiscovery, PortMapping portMapping) {
  56
  57         this.networkTransactionService = networkTransactionService;
  58         this.linkDiscovery = linkDiscovery;
  59         this.portMapping = portMapping;
  60         this.topologyShardMountedDevice = new HashMap<String,TopologyShard>();
  61         this.otnTopologyShardMountedDevice = new HashMap<String,TopologyShard>();
  62     }
  63
  64     public void init() {
  65         LOG.info("init ...");
  66     }
  67
  68     public void close() {
  69     }
  70
  71     @Override
  72     public void createOpenRoadmNode(String nodeId, String openRoadmVersion) {
  73         try {
  74             LOG.info("createOpenROADMNode: {} ", nodeId);
  75
  76             if (!portMapping.createMappingData(nodeId, openRoadmVersion)) {
  77                 LOG.warn("Could not generate port mapping for {} skipping network model creation", nodeId);
  78                 return;
  79             }
  80             NodeInfo nodeInfo = portMapping.getNode(nodeId).getNodeInfo();
  81             if (nodeInfo.getNodeType().getIntValue() == 1) {
  82                 this.linkDiscovery.readLLDP(new NodeId(nodeId), openRoadmVersion);
  83             }
  84             // node creation in clli-network
  85             Node clliNode = ClliNetwork.createNode(nodeId, nodeInfo);
  86             InstanceIdentifier<Node> iiClliNode = InstanceIdentifier.builder(Networks.class)
  87                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.CLLI_NETWORK_ID)))
  88                 .child(Node.class, clliNode.key())
  89                 .build();
  90             LOG.info("creating node in {}", NetworkUtils.CLLI_NETWORK_ID);
  91             networkTransactionService.merge(LogicalDatastoreType.CONFIGURATION, iiClliNode, clliNode,
  92                 CREATE_MISSING_PARENTS);
  93
  94             // node creation in openroadm-network
  95             Node openroadmNetworkNode = OpenRoadmNetwork.createNode(nodeId, nodeInfo);
  96             InstanceIdentifier<Node> iiopenroadmNetworkNode = InstanceIdentifier.builder(Networks.class)
  97                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID)))
  98                 .child(Node.class, openroadmNetworkNode.key())
  99                 .build();
 100             LOG.info("creating node in {}", NetworkUtils.UNDERLAY_NETWORK_ID);
 101             networkTransactionService.merge(LogicalDatastoreType.CONFIGURATION, iiopenroadmNetworkNode,
 102                 openroadmNetworkNode, CREATE_MISSING_PARENTS);
 103
 104             // nodes/links creation in openroadm-topology
 105             TopologyShard topologyShard = OpenRoadmTopology.createTopologyShard(portMapping.getNode(nodeId));
 106             if (topologyShard != null) {
 107                 this.topologyShardMountedDevice.put(nodeId, topologyShard);
 108                 for (Node openRoadmTopologyNode: topologyShard.getNodes()) {
 109                     LOG.info("creating node {} in {}", openRoadmTopologyNode.getNodeId().getValue(),
 110                             NetworkUtils.OVERLAY_NETWORK_ID);
 111                     InstanceIdentifier<Node> iiOpenRoadmTopologyNode = InstanceIdentifier.builder(Networks.class)
 112                         .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 113                         .child(Node.class, openRoadmTopologyNode.key())
 114                         .build();
 115                     networkTransactionService.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyNode,
 116                         openRoadmTopologyNode, CREATE_MISSING_PARENTS);
 117                 }
 118                 for (Link openRoadmTopologyLink: topologyShard.getLinks()) {
 119                     LOG.info("creating link {} in {}", openRoadmTopologyLink.getLinkId().getValue(),
 120                             NetworkUtils.OVERLAY_NETWORK_ID);
 121                     InstanceIdentifier<Link> iiOpenRoadmTopologyLink = InstanceIdentifier.builder(Networks.class)
 122                         .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 123                         .augmentation(Network1.class)
 124                         .child(Link.class, openRoadmTopologyLink.key())
 125                         .build();
 126                     networkTransactionService.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyLink,
 127                         openRoadmTopologyLink, CREATE_MISSING_PARENTS);
 128                 }
 129             } else {
 130                 LOG.error("Unable to create openroadm-topology shard for node {}!", nodeId);
 131             }
 132
 133             // nodes/links creation in otn-topology
 134             if (nodeInfo.getNodeType().getIntValue() == 2 && (nodeInfo.getOpenroadmVersion().getIntValue() != 1)) {
 135                 TopologyShard otnTopologyShard = OpenRoadmOtnTopology.createTopologyShard(portMapping.getNode(nodeId));
 136                 if (otnTopologyShard != null) {
 137                     this.otnTopologyShardMountedDevice.put(nodeId, otnTopologyShard);
 138                     for (Node otnTopologyNode: otnTopologyShard.getNodes()) {
 139                         LOG.info("creating otn node {} in {}", otnTopologyNode.getNodeId().getValue(),
 140                                 NetworkUtils.OTN_NETWORK_ID);
 141                         InstanceIdentifier<Node> iiOtnTopologyNode = InstanceIdentifier.builder(Networks.class)
 142                                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID)))
 143                                 .child(Node.class, otnTopologyNode.key())
 144                                 .build();
 145                         networkTransactionService.merge(LogicalDatastoreType.CONFIGURATION, iiOtnTopologyNode,
 146                             otnTopologyNode);
 147                     }
 148                     for (Link otnTopologyLink: otnTopologyShard.getLinks()) {
 149                         LOG.info("creating otn link {} in {}", otnTopologyLink.getLinkId().getValue(),
 150                                 NetworkUtils.OVERLAY_NETWORK_ID);
 151                         InstanceIdentifier<Link> iiOtnTopologyLink = InstanceIdentifier.builder(Networks.class)
 152                             .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID)))
 153                             .augmentation(Network1.class)
 154                             .child(Link.class, otnTopologyLink.key())
 155                             .build();
 156                         networkTransactionService.merge(LogicalDatastoreType.CONFIGURATION, iiOtnTopologyLink,
 157                             otnTopologyLink, CREATE_MISSING_PARENTS);
 158                     }
 159                 } else {
 160                     LOG.error("Unable to create OTN topology shard for node {}!", nodeId);
 161                 }
 162             }
 163             networkTransactionService.commit().get();
 164             LOG.info("all nodes and links created");
 165         } catch (InterruptedException | ExecutionException e) {
 166             LOG.error("ERROR: ", e);
 167         }
 168     }
 169
 170     @Override
 171     public void setOpenRoadmNodeStatus(String nodeId, NetconfNodeConnectionStatus.ConnectionStatus connectionStatus) {
 172         LOG.info("setOpenROADMNodeStatus: {} {}", nodeId, connectionStatus.name());
 173         /*
 174           TODO: set connection status of the device in model,
 175           TODO: so we don't need to keep it in memory (Set<String> currentMountedDevice)
 176           TODO: unfortunately there is no connection status OpenROADM in network models
 177           TODO: waiting for new model version
 178          */
 179     }
 180
 181     /* (non-Javadoc)
 182      * @see org.opendaylight.transportpce.networkmodel.service.NetworkModelService#deleteOpenROADMnode(java.lang.String)
 183      */
 184
 185
 186
 187     @Override
 188     public void deleteOpenRoadmnode(String nodeId) {
 189         try {
 190             NodeKey nodeIdKey = new NodeKey(new NodeId(nodeId));
 191
 192             LOG.info("deleting node in {}", NetworkUtils.UNDERLAY_NETWORK_ID);
 193             InstanceIdentifier<Node> iiopenroadmNetworkNode = InstanceIdentifier.builder(Networks.class)
 194                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID)))
 195                 .child(Node.class, nodeIdKey)
 196                 .build();
 197             this.networkTransactionService.delete(LogicalDatastoreType.CONFIGURATION, iiopenroadmNetworkNode);
 198
 199             TopologyShard topologyShard = this.topologyShardMountedDevice.get(nodeId);
 200             if (topologyShard != null) {
 201                 for (Node openRoadmTopologyNode: topologyShard .getNodes()) {
 202                     LOG.info("deleting node {} in {}", openRoadmTopologyNode.getNodeId().getValue(),
 203                         NetworkUtils.OVERLAY_NETWORK_ID);
 204                     InstanceIdentifier<Node> iiOpenRoadmTopologyNode = InstanceIdentifier.builder(Networks.class)
 205                         .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 206                         .child(Node.class, openRoadmTopologyNode.key())
 207                         .build();
 208                     this.networkTransactionService.delete(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyNode);
 209                 }
 210                 for (Link openRoadmTopologyLink: topologyShard.getLinks()) {
 211                     LOG.info("deleting link {} in {}", openRoadmTopologyLink.getLinkId().getValue(),
 212                         NetworkUtils.OVERLAY_NETWORK_ID);
 213                     InstanceIdentifier<Link> iiOpenRoadmTopologyLink = InstanceIdentifier.builder(Networks.class)
 214                         .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 215                         .augmentation(Network1.class)
 216                         .child(Link.class, openRoadmTopologyLink.key())
 217                         .build();
 218                     this.networkTransactionService.delete(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyLink);
 219                 }
 220             } else {
 221                 LOG.warn("TopologyShard for node '{}' is not present", nodeId);
 222             }
 223             @Nullable
 224             OpenroadmVersion deviceVersion = this.portMapping.getNode(nodeId).getNodeInfo().getOpenroadmVersion();
 225             @Nullable
 226             NodeTypes nodeType = this.portMapping.getNode(nodeId).getNodeInfo().getNodeType();
 227             if (nodeType.getIntValue() == 2 && deviceVersion.getIntValue() != 1) {
 228                 TopologyShard otnTopologyShard = this.otnTopologyShardMountedDevice.get(nodeId);
 229                 LOG.info("suppression de otnTopologyShard = {}", otnTopologyShard.toString());
 230                 if (otnTopologyShard != null) {
 231                     for (Node otnTopologyNode: otnTopologyShard .getNodes()) {
 232                         LOG.info("deleting node {} in {}", otnTopologyNode.getNodeId().getValue(),
 233                             NetworkUtils.OTN_NETWORK_ID);
 234                         InstanceIdentifier<Node> iiotnTopologyNode = InstanceIdentifier.builder(Networks.class)
 235                             .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID)))
 236                             .child(Node.class, otnTopologyNode.key())
 237                             .build();
 238                         this.networkTransactionService.delete(LogicalDatastoreType.CONFIGURATION, iiotnTopologyNode);
 239                     }
 240                     for (Link otnTopologyLink: otnTopologyShard.getLinks()) {
 241                         LOG.info("deleting link {} in {}", otnTopologyLink.getLinkId().getValue(),
 242                             NetworkUtils.OTN_NETWORK_ID);
 243                         InstanceIdentifier<Link> iiotnTopologyLink = InstanceIdentifier.builder(Networks.class)
 244                             .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID)))
 245                             .augmentation(Network1.class)
 246                             .child(Link.class, otnTopologyLink.key())
 247                             .build();
 248                         this.networkTransactionService.delete(LogicalDatastoreType.CONFIGURATION, iiotnTopologyLink);
 249                     }
 250                 }
 251             }
 252
 253             LOG.info("deleteOpenROADMnode: {} version {}", nodeId, deviceVersion.getName());
 254             this.portMapping.deleteMappingData(nodeId);
 255
 256             this.networkTransactionService.commit().get(1, TimeUnit.SECONDS);
 257             LOG.info("all nodes and links deleted ! ");
 258         } catch (InterruptedException | ExecutionException | TimeoutException e) {
 259             LOG.error("Error when trying to delete node : {}", nodeId, e);
 260         }
 261     }
 262 }