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 org.opendaylight.controller.md.sal.binding.api.DataBroker;
  13 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  14 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  15 import org.opendaylight.transportpce.common.NetworkUtils;
  16 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  17 import org.opendaylight.transportpce.common.mapping.PortMapping;
  18 import org.opendaylight.transportpce.networkmodel.R2RLinkDiscovery;
  19 import org.opendaylight.transportpce.networkmodel.dto.TopologyShard;
  20 import org.opendaylight.transportpce.networkmodel.util.ClliNetwork;
  21 import org.opendaylight.transportpce.networkmodel.util.OpenRoadmNetwork;
  22 import org.opendaylight.transportpce.networkmodel.util.OpenRoadmTopology;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.Network;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkId;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkKey;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NodeId;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.network.Node;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.network.NodeKey;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Network1;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.Link;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
  32 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35
  36 public class NetworkModelServiceImpl implements NetworkModelService {
  37
  38     private static final Logger LOG = LoggerFactory.getLogger(NetworkModelServiceImpl.class);
  39     private static final boolean CREATE_MISSING_PARENTS = true;
  40
  41     private final DataBroker dataBroker;
  42     private final R2RLinkDiscovery linkDiscovery;
  43     private final DeviceTransactionManager deviceTransactionManager;
  44     private final OpenRoadmTopology openRoadmTopology;
  45     private final PortMapping portMapping;
  46     private HashMap<String,TopologyShard> topologyShardMountedDevice;
  47
  48     public NetworkModelServiceImpl(final DataBroker dataBroker, final R2RLinkDiscovery linkDiscovery,
  49             DeviceTransactionManager deviceTransactionManager,
  50             OpenRoadmTopology openRoadmTopology, PortMapping portMapping) {
  51         this.dataBroker = dataBroker;
  52         this.linkDiscovery = linkDiscovery;
  53         this.deviceTransactionManager = deviceTransactionManager;
  54         this.openRoadmTopology = openRoadmTopology;
  55         this.portMapping = portMapping;
  56         this.topologyShardMountedDevice = new HashMap<String,TopologyShard>();
  57     }
  58
  59     public void init() {
  60         LOG.info("init ...");
  61     }
  62
  63     public void close() {
  64     }
  65
  66     @Override
  67     public void createOpenROADMnode(String nodeId, String nodeVersion) {
  68         try {
  69             LOG.info("createOpenROADMNode: {} ", nodeId);
  70
  71             boolean isPortMapping = this.portMapping.createMappingData(nodeId, nodeVersion);
  72             if (isPortMapping && "1.2.1".equals(this.portMapping.getNode(nodeId).getOpenroadmVersion().getName())) {
  73                 this.linkDiscovery.readLLDP(new NodeId(nodeId));
  74
  75                 Node clliNode = ClliNetwork.createNode(this.deviceTransactionManager, nodeId);
  76                 if (clliNode == null) {
  77                     LOG.error("Unable to create clli node! Node id: {}", nodeId);
  78                     return;
  79                 }
  80
  81                 Node openRoadmNode = OpenRoadmNetwork.createNode(nodeId, this.deviceTransactionManager);
  82                 if (openRoadmNode == null) {
  83                     LOG.error("Unable to create OpenRoadm node! Node id: {}", nodeId);
  84                     return;
  85                 }
  86
  87                 TopologyShard topologyShard = this.openRoadmTopology.createTopologyShard(nodeId);
  88                 if (topologyShard == null) {
  89                     LOG.error("Unable to create topology shard for node {}!", nodeId);
  90                     return;
  91                 }
  92                 this.topologyShardMountedDevice.put(nodeId, topologyShard);
  93
  94                 WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
  95                 LOG.info("creating node in {}", NetworkUtils.CLLI_NETWORK_ID);
  96                 InstanceIdentifier<Node> iiClliNode = InstanceIdentifier
  97                         .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.CLLI_NETWORK_ID)))
  98                         .child(Node.class, clliNode.key())
  99                         .build();
 100                 writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiClliNode, clliNode,
 101                         CREATE_MISSING_PARENTS);
 102                 LOG.info("creating node in {}", NetworkUtils.UNDERLAY_NETWORK_ID);
 103                 InstanceIdentifier<Node> iiOpenRoadmNode = InstanceIdentifier
 104                         .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID)))
 105                         .child(Node.class, openRoadmNode.key())
 106                         .build();
 107                 writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmNode, openRoadmNode,
 108                         CREATE_MISSING_PARENTS);
 109                 for (Node openRoadmTopologyNode: topologyShard.getNodes()) {
 110                     LOG.info("creating node {} in {}", openRoadmTopologyNode.getNodeId().getValue(),
 111                             NetworkUtils.OVERLAY_NETWORK_ID);
 112                     InstanceIdentifier<Node> iiOpenRoadmTopologyNode = InstanceIdentifier
 113                             .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 114                             .child(Node.class, openRoadmTopologyNode.key())
 115                             .build();
 116                     writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyNode,
 117                             openRoadmTopologyNode, CREATE_MISSING_PARENTS);
 118                 }
 119                 for (Link openRoadmTopologyLink: topologyShard.getLinks()) {
 120                     LOG.info("creating link {} in {}", openRoadmTopologyLink.getLinkId().getValue(),
 121                             NetworkUtils.OVERLAY_NETWORK_ID);
 122                     InstanceIdentifier<Link> iiOpenRoadmTopologyLink = InstanceIdentifier
 123                             .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 124                             .augmentation(Network1.class)
 125                             .child(Link.class, openRoadmTopologyLink.key())
 126                             .build();
 127                     writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyLink,
 128                             openRoadmTopologyLink, CREATE_MISSING_PARENTS);
 129                 }
 130                 writeTransaction.submit().get();
 131                 LOG.info("all nodes and links created");
 132             } else {
 133                 LOG.warn("openroadm-topology is not managed yet with openROADM device 2.2");
 134             }
 135         } catch (InterruptedException | ExecutionException e) {
 136             LOG.error("ERROR: ", e);
 137         }
 138     }
 139
 140     @Override
 141     public void setOpenROADMnodeStatus(String nodeId, NetconfNodeConnectionStatus.ConnectionStatus connectionStatus) {
 142         LOG.info("setOpenROADMNodeStatus: {} {}", nodeId, connectionStatus.name());
 143         /*
 144           TODO: set connection status of the device in model,
 145           TODO: so we don't need to keep it in memory (Set<String> currentMountedDevice)
 146           TODO: unfortunately there is no connection status OpenROADM in network models
 147           TODO: waiting for new model version
 148          */
 149     }
 150
 151     /* (non-Javadoc)
 152      * @see org.opendaylight.transportpce.networkmodel.service.NetworkModelService#deleteOpenROADMnode(java.lang.String)
 153      */
 154     @Override
 155     public void deleteOpenROADMnode(String nodeId) {
 156         try {
 157             LOG.info("deleteOpenROADMnode: {} ", nodeId);
 158             this.portMapping.deleteMappingData(nodeId);
 159
 160             NodeKey nodeIdKey = new NodeKey(new NodeId(nodeId));
 161             WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
 162             LOG.info("deleting node in {}", NetworkUtils.CLLI_NETWORK_ID);
 163             InstanceIdentifier<Node> iiClliNode = InstanceIdentifier
 164                     .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.CLLI_NETWORK_ID)))
 165                     .child(Node.class, nodeIdKey)
 166                     .build();
 167             writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, iiClliNode);
 168             LOG.info("deleting node in {}", NetworkUtils.UNDERLAY_NETWORK_ID);
 169             InstanceIdentifier<Node> iiOpenRoadmNode = InstanceIdentifier
 170                     .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID)))
 171                     .child(Node.class, nodeIdKey)
 172                     .build();
 173             writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmNode);
 174             TopologyShard topologyShard = this.topologyShardMountedDevice.get(nodeId);
 175             if (topologyShard != null) {
 176                 LOG.info("TopologyShard for node '{}' is present", nodeId);
 177                 for (Node openRoadmTopologyNode: topologyShard .getNodes()) {
 178                     LOG.info("deleting node {} in {}", openRoadmTopologyNode.getNodeId().getValue(),
 179                             NetworkUtils.OVERLAY_NETWORK_ID);
 180                     InstanceIdentifier<Node> iiOpenRoadmTopologyNode = InstanceIdentifier
 181                             .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 182                             .child(Node.class, openRoadmTopologyNode.key())
 183                             .build();
 184                     writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyNode);
 185                 }
 186                 for (Link openRoadmTopologyLink: topologyShard.getLinks()) {
 187                     LOG.info("deleting link {} in {}", openRoadmTopologyLink.getLinkId().getValue(),
 188                             NetworkUtils.OVERLAY_NETWORK_ID);
 189                     InstanceIdentifier<Link> iiOpenRoadmTopologyLink = InstanceIdentifier
 190                             .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 191                             .augmentation(Network1.class)
 192                             .child(Link.class, openRoadmTopologyLink.key())
 193                             .build();
 194                     writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, iiOpenRoadmTopologyLink);
 195                 }
 196             } else {
 197                 LOG.warn("TopologyShard for node '{}' is not present", nodeId);
 198             }
 199             writeTransaction.submit().get();
 200             LOG.info("all nodes and links deleted ! ");
 201         } catch (InterruptedException | ExecutionException e) {
 202             LOG.error("Error when trying to delete node : {}", nodeId, e);
 203         }
 204     }
 205 }