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