common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingImpl.java

   1 /*
   2  * Copyright © 2017 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
   9 package org.opendaylight.transportpce.common.mapping;
  10
  11 import com.google.common.util.concurrent.CheckedFuture;
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import java.util.Optional;
  15 import java.util.concurrent.ExecutionException;
  16 import java.util.concurrent.TimeUnit;
  17 import java.util.concurrent.TimeoutException;
  18 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  19 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  20 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  23 import org.opendaylight.transportpce.common.Timeouts;
  24 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  25 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  26 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
  27 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl;
  28 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.Network;
  29 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.NetworkBuilder;
  30 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.Nodes;
  31 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.NodesBuilder;
  32 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.NodesKey;
  33 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.CpToDegree;
  34 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.Mapping;
  35 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.MappingBuilder;
  36 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.MappingKey;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.NodeTypes;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.Ports;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.PortsKey;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacks;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  44 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Info;
  45 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.InterfaceType;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpenROADMOpticalMultiplex;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpticalTransport;
  49 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52
  53 public class PortMappingImpl implements PortMapping {
  54
  55     private static final Logger LOG = LoggerFactory.getLogger(PortMappingImpl.class);
  56
  57     private final DataBroker dataBroker;
  58     private final DeviceTransactionManager deviceTransactionManager;
  59     private final OpenRoadmInterfaces openRoadmInterfaces;
  60
  61     public PortMappingImpl(DataBroker dataBroker, DeviceTransactionManager deviceTransactionManager,
  62         OpenRoadmInterfaces openRoadmInterfaces) {
  63         this.dataBroker = dataBroker;
  64         this.deviceTransactionManager = deviceTransactionManager;
  65         this.openRoadmInterfaces = openRoadmInterfaces;
  66     }
  67
  68
  69
  70
  71
  72     /**
  73      * This private method builds the mapping object to be pushed in MD-SAL in
  74      * order to save port mapping. In case of TTP ports, it also saves the
  75      * OTS,OMS interfaces provisioned on the port.
  76      *
  77      * @param port
  78      *            Reference to device's port subtree object.
  79      * @param circuitPackName
  80      *            Name of cp where port exists.
  81      * @param logicalConnectionPoint
  82      *            logical name of the port.
  83      *
  84      * @return true/false based on status of operation
  85      */
  86
  87     public Mapping createMappingObject(String nodeId, Ports port, String circuitPackName,
  88         String logicalConnectionPoint) {
  89         MappingBuilder mpBldr = new MappingBuilder();
  90         mpBldr.withKey(new MappingKey(logicalConnectionPoint)).setLogicalConnectionPoint(logicalConnectionPoint)
  91             .setSupportingCircuitPackName(circuitPackName).setSupportingPort(port.getPortName());
  92
  93         // Get OMS and OTS interface provisioned on the TTP's
  94         if (logicalConnectionPoint.contains(OpenRoadmInterfacesImpl.TTP_TOKEN) && (port.getInterfaces() != null)) {
  95             for (Interfaces interfaces : port.getInterfaces()) {
  96                 try {
  97                     Optional<Interface> openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
  98                         interfaces.getInterfaceName());
  99                     if (openRoadmInterface.isPresent()) {
 100                         Class<? extends InterfaceType> interfaceType = openRoadmInterface.get().getType();
 101                         // Check if interface type is OMS or OTS
 102                         if (interfaceType.equals(OpenROADMOpticalMultiplex.class)) {
 103                             mpBldr.setSupportingOms(interfaces.getInterfaceName());
 104                         }
 105                         if (interfaceType.equals(OpticalTransport.class)) {
 106                             mpBldr.setSupportingOts(interfaces.getInterfaceName());
 107                         }
 108                     } else {
 109                         LOG.warn("Interface {} from node {} was null!", interfaces.getInterfaceName(), nodeId);
 110                     }
 111                 } catch (OpenRoadmInterfaceException ex) {
 112                     LOG.warn("Error while getting interface {} from node {}!", interfaces.getInterfaceName(), nodeId,
 113                         ex);
 114                 }
 115             }
 116         }
 117         return mpBldr.build();
 118     }
 119
 120
 121     /**
 122      * This method for ports the portMapping corresponding to the
 123      * portmapping.yang file to the MD-SAL datastore.
 124      *
 125      * <p>
 126      * 1. Supporting circuit pack 2. Supporting port 3. Supporting OMS interface
 127      * (if port on ROADM)
 128      *
 129      * @param deviceInfo
 130      *            Info subtree from the device.
 131      * @param portMapList
 132      *            Reference to the list containing the mapping to be pushed to
 133      *            MD-SAL.
 134      *
 135      * @return Result true/false based on status of operation.
 136      */
 137     private boolean postPortMapping(Info deviceInfo, List<Mapping> portMapList, Integer nodeType,
 138         List<CpToDegree> cp2DegreeList) {
 139         NodesBuilder nodesBldr = new NodesBuilder();
 140         nodesBldr.withKey(new NodesKey(deviceInfo.getNodeId())).setNodeId(deviceInfo.getNodeId());
 141         nodesBldr.setNodeType(NodeTypes.forValue(nodeType));
 142
 143         if (portMapList != null) {
 144             nodesBldr.setMapping(portMapList);
 145         }
 146         if (cp2DegreeList != null) {
 147             nodesBldr.setCpToDegree(cp2DegreeList);
 148         }
 149
 150         List<Nodes> nodesList = new ArrayList<>();
 151         nodesList.add(nodesBldr.build());
 152
 153         NetworkBuilder nwBldr = new NetworkBuilder();
 154         nwBldr.setNodes(nodesList);
 155
 156         final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
 157         InstanceIdentifier<Network> nodesIID = InstanceIdentifier.builder(Network.class).build();
 158         Network network = nwBldr.build();
 159         writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, nodesIID, network);
 160         CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
 161         try {
 162             submit.checkedGet();
 163             return true;
 164
 165         } catch (TransactionCommitFailedException e) {
 166             LOG.warn("Failed to post {}", network, e);
 167             return false;
 168         }
 169     }
 170
 171     @Override
 172     public Mapping getMapping(String nodeId, String logicalConnPoint) {
 173
 174         /*
 175          * Getting physical mapping corresponding to logical connection point
 176          */
 177         InstanceIdentifier<Mapping> portMappingIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
 178             new NodesKey(nodeId)).child(Mapping.class, new MappingKey(logicalConnPoint)).build();
 179         try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
 180             Optional<Mapping> mapObject = readTx.read(LogicalDatastoreType.CONFIGURATION, portMappingIID).get()
 181                 .toJavaUtil();
 182             if (mapObject.isPresent()) {
 183                 Mapping mapping = mapObject.get();
 184                 LOG.info("Found mapping for the logical port {}. Mapping: {}", logicalConnPoint, mapping.toString());
 185                 return mapping;
 186             } else {
 187                 LOG.warn("Could not find mapping for logical connection point {} for nodeId {}", logicalConnPoint,
 188                     nodeId);
 189             }
 190         } catch (InterruptedException | ExecutionException ex) {
 191             LOG.error("Unable to read mapping for logical connection point : {} for nodeId {}", logicalConnPoint,
 192                 nodeId, ex);
 193         }
 194         return null;
 195     }
 196
 197     @Override
 198     public void deleteMappingData(String nodeId) {
 199         LOG.info("Deleting Mapping Data corresponding at node '{}'", nodeId);
 200         WriteTransaction rw = this.dataBroker.newWriteOnlyTransaction();
 201         InstanceIdentifier<Nodes> nodesIID = InstanceIdentifier.create(Network.class)
 202             .child(Nodes.class, new NodesKey(nodeId));
 203         rw.delete(LogicalDatastoreType.CONFIGURATION, nodesIID);
 204         try {
 205             rw.submit().get(1, TimeUnit.SECONDS);
 206             LOG.info("Port mapping removal for node '{}'", nodeId);
 207         } catch (InterruptedException | ExecutionException | TimeoutException e) {
 208             LOG.error("Error for removing port mapping infos for node '{}'", nodeId);
 209         }
 210
 211     }
 212
 213     @Override
 214     public boolean updateMapping(String nodeId, Mapping oldMapping) {
 215         LOG.info("Updating Mapping Data {} for node {}", oldMapping, nodeId);
 216         InstanceIdentifier<Ports> portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
 217             CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName())).child(Ports.class,
 218                 new PortsKey(oldMapping.getSupportingPort()));
 219         if ((oldMapping != null) && (nodeId != null)) {
 220             try {
 221                 Optional<Ports> portObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 222                     LogicalDatastoreType.OPERATIONAL, portIId, Timeouts.DEVICE_READ_TIMEOUT,
 223                     Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 224                 if (portObject.isPresent()) {
 225                     Ports port = portObject.get();
 226                     Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(),
 227                         oldMapping.getLogicalConnectionPoint());
 228
 229                     final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
 230                     InstanceIdentifier<Mapping> mapIID = InstanceIdentifier.create(Network.class).child(Nodes.class,
 231                         new NodesKey(nodeId)).child(Mapping.class, new MappingKey(oldMapping
 232                             .getLogicalConnectionPoint()));
 233                     writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, mapIID, newMapping);
 234                     CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
 235                     submit.checkedGet();
 236                     return true;
 237                 }
 238                 return false;
 239             } catch (TransactionCommitFailedException e) {
 240                 LOG.error("Transaction Commit Error updating Mapping {} for node {}", oldMapping
 241                     .getLogicalConnectionPoint(), nodeId, e);
 242                 return false;
 243             }
 244         } else {
 245             LOG.error("Impossible to update mapping");
 246             return false;
 247         }
 248     }
 249
 250     @Override
 251     public boolean createMappingData(Info deviceInfo, List<Mapping> portMapList, List<CpToDegree> degreeCpList) {
 252         LOG.info("Create Mapping Data for node {}", deviceInfo.getNodeId());
 253         return postPortMapping(deviceInfo, portMapList, deviceInfo.getNodeType().getIntValue(), degreeCpList);
 254     }
 255
 256 }