opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.java

   1 /**
   2  * Copyright (c) 2014 Cisco Systems, Inc. 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.controller.sal.compatibility;
   9
  10 import java.util.Date;
  11 import java.util.HashSet;
  12 import java.util.List;
  13
  14 import org.opendaylight.controller.sal.common.util.Arguments;
  15 import org.opendaylight.controller.sal.core.AdvertisedBandwidth;
  16 import org.opendaylight.controller.sal.core.Bandwidth;
  17 import org.opendaylight.controller.sal.core.Buffers;
  18 import org.opendaylight.controller.sal.core.Capabilities;
  19 import org.opendaylight.controller.sal.core.Config;
  20 import org.opendaylight.controller.sal.core.ConstructionException;
  21 import org.opendaylight.controller.sal.core.MacAddress;
  22 import org.opendaylight.controller.sal.core.Name;
  23 import org.opendaylight.controller.sal.core.NodeConnector.NodeConnectorIDType;
  24 import org.opendaylight.controller.sal.core.PeerBandwidth;
  25 import org.opendaylight.controller.sal.core.Property;
  26 import org.opendaylight.controller.sal.core.SupportedBandwidth;
  27 import org.opendaylight.controller.sal.core.Tables;
  28 import org.opendaylight.controller.sal.core.TimeStamp;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FeatureCapability;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorUpdated;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityArpMatchIp;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityFlowStats;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityIpReasm;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityPortStats;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityQueueStats;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityStp;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityTableStats;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowNode;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowNodeConnector;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.flow.node.SwitchFeatures;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortConfig;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortFeatures;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.flow.capable.port.State;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  57 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  58
  59 import com.google.common.base.Objects;
  60 import com.google.common.base.Preconditions;
  61
  62 public final class NodeMapping {
  63   public final static String MD_SAL_TYPE = "MD_SAL";
  64
  65   private final static Class<Node> NODE_CLASS = Node.class;
  66
  67   private final static Class<NodeConnector> NODECONNECTOR_CLASS = NodeConnector.class;
  68
  69   private NodeMapping() {
  70     throw new UnsupportedOperationException("Utility class. Instantiation is not allowed.");
  71   }
  72
  73   public static org.opendaylight.controller.sal.core.Node toADNode(final InstanceIdentifier<? extends Object> node) throws ConstructionException {
  74     NodeId nodeId = NodeMapping.toNodeId(node);
  75     return NodeMapping.toADNode(nodeId);
  76   }
  77
  78   public static org.opendaylight.controller.sal.core.Node toADNode(final NodeId id) throws ConstructionException {
  79       String aDNodeId = NodeMapping.toADNodeId(id);
  80       return  new org.opendaylight.controller.sal.core.Node(NodeMapping.MD_SAL_TYPE, aDNodeId);
  81   }
  82
  83   public static NodeId toNodeId(final InstanceIdentifier<?> id) {
  84     final NodeKey key = id.firstKeyOf(Node.class, NodeKey.class);
  85     Preconditions.checkArgument(key != null, "No node identifier found in %s", id);
  86     return key.getId();
  87   }
  88
  89   public static String toADNodeId(final NodeId nodeId) {
  90     return nodeId.getValue();
  91   }
  92
  93   public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorRef source) throws ConstructionException {
  94     final InstanceIdentifier<?> id = Preconditions.checkNotNull(source.getValue());
  95     final NodeConnectorKey key = id.firstKeyOf(NodeConnector.class, NodeConnectorKey.class);
  96     return NodeMapping.toADNodeConnector(key.getId(), NodeMapping.toNodeId(id));
  97   }
  98
  99   public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorId ncid, final NodeId nid) throws ConstructionException {
 100     String nodeConnectorType = NodeMapping.toNodeConnectorType(ncid, nid);
 101     Object aDNodeConnectorId = NodeMapping.toADNodeConnectorId(ncid, nid);
 102     org.opendaylight.controller.sal.core.Node aDNode = NodeMapping.toADNode(nid);
 103     return new org.opendaylight.controller.sal.core.NodeConnector(nodeConnectorType, aDNodeConnectorId, aDNode);
 104   }
 105
 106   public static String toNodeConnectorType(final NodeConnectorId ncId, final NodeId nodeId) {
 107     if (ncId.equals(toLocalNodeConnectorId(nodeId))) {
 108         return NodeConnectorIDType.SWSTACK;
 109     } else if (ncId.equals(toNormalNodeConnectorId(nodeId))) {
 110         return NodeConnectorIDType.HWPATH;
 111     } else if (ncId.equals(toControllerNodeConnectorId(nodeId))) {
 112         return NodeConnectorIDType.CONTROLLER;
 113     }
 114     return MD_SAL_TYPE;
 115   }
 116
 117   public static Object toADNodeConnectorId(final NodeConnectorId nodeConnectorId, final NodeId nodeId) {
 118     if (nodeConnectorId.equals(toLocalNodeConnectorId(nodeId)) ||
 119         nodeConnectorId.equals(toNormalNodeConnectorId(nodeId)) ||
 120         nodeConnectorId.equals(toControllerNodeConnectorId(nodeId))) {
 121         return org.opendaylight.controller.sal.core.NodeConnector.SPECIALNODECONNECTORID;
 122     }
 123     return nodeConnectorId.getValue();
 124   }
 125
 126   public static NodeConnectorId toControllerNodeConnectorId(final NodeId node) {
 127     return new NodeConnectorId(node.getValue() + ":" + 4294967293L);
 128   }
 129
 130   public static NodeConnectorId toLocalNodeConnectorId(final NodeId node) {
 131     return new NodeConnectorId(node.getValue() + ":" + 4294967294L);
 132   }
 133
 134   public static NodeConnectorId toNormalNodeConnectorId(final NodeId node) {
 135     return new NodeConnectorId(node.getValue() + ":" + 4294967290L);
 136   }
 137
 138   public static NodeRef toNodeRef(final org.opendaylight.controller.sal.core.Node node) {
 139     Preconditions.checkArgument(MD_SAL_TYPE.equals(node.getType()));
 140     final String nodeId = Arguments.<String>checkInstanceOf(node.getID(), String.class);
 141     final NodeKey nodeKey = new NodeKey(new NodeId(nodeId));
 142     final InstanceIdentifier<Node> nodePath = InstanceIdentifier.builder(Nodes.class).child(NODE_CLASS, nodeKey).toInstance();
 143     return new NodeRef(nodePath);
 144   }
 145
 146   public static NodeConnectorRef toNodeConnectorRef(final org.opendaylight.controller.sal.core.NodeConnector nodeConnector) {
 147
 148     final NodeRef node = NodeMapping.toNodeRef(nodeConnector.getNode());
 149     @SuppressWarnings("unchecked")
 150     final InstanceIdentifier<Node> nodePath = ((InstanceIdentifier<Node>) node.getValue());
 151     NodeConnectorId nodeConnectorId = null;
 152
 153     if (nodeConnector.getID().equals(org.opendaylight.controller.sal.core.NodeConnector.SPECIALNODECONNECTORID)) {
 154         final NodeId nodeId = toNodeId(nodePath);
 155         final String nodeConnectorType = nodeConnector.getType();
 156         if (nodeConnectorType.equals(NodeConnectorIDType.SWSTACK)) {
 157             nodeConnectorId = toLocalNodeConnectorId(nodeId);
 158         } else if (nodeConnectorType.equals(NodeConnectorIDType.HWPATH)) {
 159             nodeConnectorId = toNormalNodeConnectorId(nodeId);
 160         } else if (nodeConnectorType.equals(NodeConnectorIDType.CONTROLLER)) {
 161             nodeConnectorId = toControllerNodeConnectorId(nodeId);
 162         }
 163     } else {
 164         nodeConnectorId = new NodeConnectorId(Arguments.<String>checkInstanceOf(nodeConnector.getID(), String.class));
 165     }
 166     final NodeConnectorKey connectorKey = new NodeConnectorKey(nodeConnectorId);
 167     final InstanceIdentifier<NodeConnector> path = nodePath.child(NODECONNECTOR_CLASS, connectorKey);
 168     return new NodeConnectorRef(path);
 169   }
 170
 171   public static org.opendaylight.controller.sal.core.Node toADNode(final NodeRef node) throws ConstructionException {
 172     return NodeMapping.toADNode(node.getValue());
 173   }
 174
 175   public static HashSet<Property> toADNodeConnectorProperties(final NodeConnectorUpdated nc) {
 176     final FlowCapableNodeConnectorUpdated fcncu = nc.<FlowCapableNodeConnectorUpdated>getAugmentation(FlowCapableNodeConnectorUpdated.class);
 177     if (!Objects.equal(fcncu, null)) {
 178       return NodeMapping.toADNodeConnectorProperties(fcncu);
 179     }
 180     return new HashSet<Property>();
 181   }
 182
 183   public static HashSet<Property> toADNodeConnectorProperties(final NodeConnector nc) {
 184     final FlowCapableNodeConnector fcnc = nc.<FlowCapableNodeConnector>getAugmentation(FlowCapableNodeConnector.class);
 185     if (!Objects.equal(fcnc, null)) {
 186       return NodeMapping.toADNodeConnectorProperties(fcnc);
 187     }
 188     return new HashSet<Property>();
 189   }
 190
 191   public static HashSet<Property> toADNodeConnectorProperties(final FlowNodeConnector fcncu) {
 192
 193     final HashSet<org.opendaylight.controller.sal.core.Property> props = new HashSet<>();
 194     if (fcncu != null) {
 195         if (fcncu.getCurrentFeature() != null && toAdBandwidth(fcncu.getCurrentFeature()) != null) {
 196             props.add(toAdBandwidth(fcncu.getCurrentFeature()));
 197         }
 198         if (fcncu.getAdvertisedFeatures() != null && toAdAdvertizedBandwidth(fcncu.getAdvertisedFeatures()) != null) {
 199             props.add(toAdAdvertizedBandwidth(fcncu.getAdvertisedFeatures()));
 200         }
 201         if (fcncu.getSupported() != null && toAdSupportedBandwidth(fcncu.getSupported()) != null) {
 202             props.add(toAdSupportedBandwidth(fcncu.getSupported()));
 203         }
 204         if (fcncu.getPeerFeatures() != null && toAdPeerBandwidth(fcncu.getPeerFeatures()) != null) {
 205             props.add(toAdPeerBandwidth(fcncu.getPeerFeatures()));
 206         }
 207         if (fcncu.getName() != null && toAdName(fcncu.getName()) != null) {
 208             props.add(toAdName(fcncu.getName()));
 209         }
 210         if (fcncu.getConfiguration() != null && toAdConfig(fcncu.getConfiguration()) != null) {
 211             props.add(toAdConfig(fcncu.getConfiguration()));
 212         }
 213         if (fcncu.getState() != null && toAdState(fcncu.getState()) != null) {
 214             props.add(toAdState(fcncu.getState()));
 215         }
 216     }
 217     return props;
 218   }
 219
 220   public static Name toAdName(final String name) {
 221     return new Name(name);
 222   }
 223
 224   public static Config toAdConfig(final PortConfig pc) {
 225     Config config = null;
 226     if (pc.isPORTDOWN()) {
 227         config = new Config(Config.ADMIN_DOWN);
 228     } else {
 229         config = new Config(Config.ADMIN_UP);
 230     }
 231     return config;
 232   }
 233
 234   public static org.opendaylight.controller.sal.core.State toAdState(final State s) {
 235
 236     org.opendaylight.controller.sal.core.State state = null;
 237     if (s.isLinkDown()) {
 238         state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_DOWN);
 239     } else {
 240         state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_UP);
 241     }
 242     return state;
 243   }
 244
 245   public static Bandwidth toAdBandwidth(final PortFeatures pf) {
 246     Bandwidth bw = null;
 247     if (pf.isTenMbHd() || pf.isTenMbFd()) {
 248         bw = new Bandwidth(Bandwidth.BW10Mbps);
 249     } else if (pf.isHundredMbHd() || pf.isHundredMbFd()) {
 250         bw = new Bandwidth(Bandwidth.BW100Mbps);
 251     } else if (pf.isOneGbHd() || pf.isOneGbFd()) {
 252         bw = new Bandwidth(Bandwidth.BW1Gbps);
 253     } else if (pf.isOneGbFd()) {
 254         bw = new Bandwidth(Bandwidth.BW10Gbps);
 255     } else if (pf.isTenGbFd()) {
 256         bw = new Bandwidth(Bandwidth.BW10Gbps);
 257     } else if (pf.isFortyGbFd()) {
 258         bw = new Bandwidth(Bandwidth.BW40Gbps);
 259     } else if (pf.isHundredGbFd()) {
 260         bw = new Bandwidth(Bandwidth.BW100Gbps);
 261     } else if (pf.isOneTbFd()) {
 262         bw = new Bandwidth(Bandwidth.BW1Tbps);
 263     }
 264     return bw;
 265   }
 266
 267   public static AdvertisedBandwidth toAdAdvertizedBandwidth(final PortFeatures pf) {
 268     AdvertisedBandwidth abw = null;
 269     final Bandwidth bw = toAdBandwidth(pf);
 270     if (bw != null) {
 271         abw = new AdvertisedBandwidth(bw.getValue());
 272     }
 273     return abw;
 274   }
 275
 276   public static SupportedBandwidth toAdSupportedBandwidth(final PortFeatures pf) {
 277     SupportedBandwidth sbw = null;
 278     final Bandwidth bw = toAdBandwidth(pf);
 279     if (bw != null) {
 280         sbw = new SupportedBandwidth(bw.getValue());
 281     }
 282     return sbw;
 283   }
 284
 285   public static PeerBandwidth toAdPeerBandwidth(final PortFeatures pf) {
 286     PeerBandwidth pbw = null;
 287     final Bandwidth bw = toAdBandwidth(pf);
 288     if (bw != null) {
 289         pbw = new PeerBandwidth(bw.getValue());
 290     }
 291     return pbw;
 292   }
 293
 294   public static HashSet<Property> toADNodeProperties(final NodeUpdated nu) {
 295     final FlowCapableNodeUpdated fcnu = nu.getAugmentation(FlowCapableNodeUpdated.class);
 296     if (fcnu != null) {
 297         return toADNodeProperties(fcnu, nu.getId());
 298     }
 299     return new HashSet<org.opendaylight.controller.sal.core.Property>();
 300   }
 301
 302   public static HashSet<Property> toADNodeProperties(final FlowNode fcnu, final NodeId id) {
 303
 304     final HashSet<org.opendaylight.controller.sal.core.Property> props = new HashSet<>();
 305
 306     if (fcnu != null) {
 307         props.add(toADTimestamp());
 308
 309         // props.add(fcnu.supportedActions.toADActions) - TODO
 310         if (id != null) {
 311             props.add(toADMacAddress(id));
 312         }
 313         SwitchFeatures switchFeatures = fcnu.getSwitchFeatures();
 314         if (switchFeatures != null) {
 315             if (switchFeatures.getMaxTables() != null) {
 316                 props.add(toADTables(switchFeatures.getMaxTables()));
 317             }
 318             if (switchFeatures.getCapabilities() != null) {
 319                 props.add(toADCapabiliities(switchFeatures.getCapabilities()));
 320             }
 321             if (switchFeatures.getMaxBuffers() != null) {
 322                 props.add(toADBuffers(switchFeatures.getMaxBuffers()));
 323             }
 324         }
 325     }
 326     return props;
 327   }
 328
 329   public static TimeStamp toADTimestamp() {
 330     final Date date = new Date();
 331     final TimeStamp timestamp = new TimeStamp(date.getTime(), "connectedSince");
 332     return timestamp;
 333   }
 334
 335   public static MacAddress toADMacAddress(final NodeId id) {
 336     final String nodeId = id.getValue().replaceAll("openflow:", "");
 337     long lNodeId = Long.parseLong(nodeId);
 338     lNodeId = Long.valueOf(lNodeId).longValue();
 339     byte[] bytesFromDpid = ToSalConversionsUtils.bytesFromDpid(lNodeId);
 340     return new MacAddress(bytesFromDpid);
 341   }
 342
 343   public static Tables toADTables(final Short tables) {
 344     return new Tables(tables.byteValue());
 345   }
 346
 347   public static Capabilities toADCapabiliities(final List<Class<? extends FeatureCapability>> capabilities) {
 348
 349     int b = 0;
 350     for (Class<? extends FeatureCapability> capability : capabilities) {
 351         if (capability.equals(FlowFeatureCapabilityFlowStats.class)) {
 352             b = Capabilities.CapabilitiesType.FLOW_STATS_CAPABILITY.getValue() | b;
 353         } else if (capability.equals(FlowFeatureCapabilityTableStats.class)) {
 354             b = Capabilities.CapabilitiesType.TABLE_STATS_CAPABILITY.getValue() | b;
 355         } else if (capability.equals(FlowFeatureCapabilityPortStats.class)) {
 356             b = Capabilities.CapabilitiesType.PORT_STATS_CAPABILITY.getValue() | b;
 357         } else if (capability.equals(FlowFeatureCapabilityStp.class)) {
 358             b = Capabilities.CapabilitiesType.STP_CAPABILITY.getValue() | b;
 359         } else if (capability.equals(FlowFeatureCapabilityIpReasm.class)) {
 360             b = Capabilities.CapabilitiesType.IP_REASSEM_CAPABILITY.getValue() | b;
 361         } else if (capability.equals(FlowFeatureCapabilityQueueStats.class)) {
 362             b = Capabilities.CapabilitiesType.QUEUE_STATS_CAPABILITY.getValue() | b;
 363         } else if (capability.equals(FlowFeatureCapabilityArpMatchIp.class)) {
 364             b = Capabilities.CapabilitiesType.ARP_MATCH_IP_CAPABILITY.getValue() | b;
 365         }
 366     }
 367     return new Capabilities(b);
 368   }
 369
 370   public static Buffers toADBuffers(final Long buffers) {
 371     return new Buffers(buffers.intValue());
 372   }
 373 }