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 com.google.common.annotations.VisibleForTesting;
  11 import com.google.common.base.Objects;
  12 import com.google.common.base.Preconditions;
  13 import org.opendaylight.controller.sal.common.util.Arguments;
  14 import org.opendaylight.controller.sal.core.AdvertisedBandwidth;
  15 import org.opendaylight.controller.sal.core.Bandwidth;
  16 import org.opendaylight.controller.sal.core.Buffers;
  17 import org.opendaylight.controller.sal.core.Capabilities;
  18 import org.opendaylight.controller.sal.core.Config;
  19 import org.opendaylight.controller.sal.core.ConstructionException;
  20 import org.opendaylight.controller.sal.core.Description;
  21 import org.opendaylight.controller.sal.core.MacAddress;
  22 import org.opendaylight.controller.sal.core.Name;
  23 import org.opendaylight.controller.sal.core.Node.NodeIDType;
  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.flow.types.rev131026.OutputPortValues;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  59 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  60 import org.slf4j.Logger;
  61 import org.slf4j.LoggerFactory;
  62
  63 import java.math.BigInteger;
  64 import java.util.Date;
  65 import java.util.HashSet;
  66 import java.util.List;
  67 import java.util.regex.Pattern;
  68
  69 public final class NodeMapping {
  70
  71     private static final Logger LOG = LoggerFactory
  72             .getLogger(NodeMapping.class);
  73
  74     /**
  75      * openflow id prefix
  76      */
  77     public static final String OPENFLOW_ID_PREFIX = "openflow:";
  78
  79     public final static String MD_SAL_TYPE = "MD_SAL_DEPRECATED";
  80
  81     private final static Class<Node> NODE_CLASS = Node.class;
  82
  83     private final static Class<NodeConnector> NODECONNECTOR_CLASS = NodeConnector.class;
  84
  85     private final static Pattern COLON_NUMBERS_EOL = Pattern.compile(":[0-9]+$");
  86
  87     private final static Pattern NUMBERS_ONLY = Pattern.compile("[0-9]+");
  88
  89     private final static Pattern ALL_CHARS_TO_COLON = Pattern.compile("^.*:");
  90
  91     private NodeMapping() {
  92         throw new UnsupportedOperationException("Utility class. Instantiation is not allowed.");
  93     }
  94
  95     public static org.opendaylight.controller.sal.core.Node toADNode(final InstanceIdentifier<? extends Object> node) throws ConstructionException {
  96         NodeId nodeId = NodeMapping.toNodeId(node);
  97         return NodeMapping.toADNode(nodeId);
  98     }
  99
 100     public static org.opendaylight.controller.sal.core.Node toADNode(final NodeId id) throws ConstructionException {
 101         String nodeId = NodeMapping.toADNodeId(id);
 102         String nodeIdasNumber = nodeId.replaceFirst("^.*:", "");
 103         if (isInteger(nodeIdasNumber)) {
 104             Long aDNodeId = openflowFullNodeIdToLong(nodeIdasNumber);
 105             return new org.opendaylight.controller.sal.core.Node(NodeIDType.OPENFLOW, aDNodeId);
 106         } else {
 107             return new org.opendaylight.controller.sal.core.Node(NodeIDType.PRODUCTION, nodeId);
 108         }
 109     }
 110
 111     /**
 112      * @param adNodeId
 113      * @return nodeId as long
 114      */
 115     @VisibleForTesting
 116     public static Long openflowFullNodeIdToLong(String adNodeId) {
 117         if (adNodeId == null) {
 118             return null;
 119         }
 120         return new BigInteger(adNodeId).longValue();
 121     }
 122
 123     public static NodeId toNodeId(final InstanceIdentifier<?> id) {
 124         final NodeKey key = id.firstKeyOf(Node.class, NodeKey.class);
 125         Preconditions.checkArgument(key != null, "No node identifier found in %s", id);
 126         return key.getId();
 127     }
 128
 129     /**
 130      * @param nodeId containing "&lt;NodeTypeString&gt;:&lt;plainIntegerId&gt;"
 131      * @return adNodeId form
 132      */
 133     public static String toADNodeId(final NodeId nodeId) {
 134         if (nodeId == null) {
 135             return null;
 136         }
 137         return nodeId.getValue();
 138     }
 139
 140     public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorRef source) throws ConstructionException {
 141         final InstanceIdentifier<?> id = Preconditions.checkNotNull(source.getValue());
 142         final NodeConnectorKey key = id.firstKeyOf(NodeConnector.class, NodeConnectorKey.class);
 143         return NodeMapping.toADNodeConnector(key.getId(), NodeMapping.toNodeId(id));
 144     }
 145
 146     public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorId ncid, final NodeId nid) throws ConstructionException {
 147         String nodeConnectorType = NodeMapping.toNodeConnectorType(ncid, nid);
 148         Object aDNodeConnectorId = NodeMapping.toADNodeConnectorId(ncid, nid);
 149         org.opendaylight.controller.sal.core.Node aDNode = NodeMapping.toADNode(nid);
 150         return new org.opendaylight.controller.sal.core.NodeConnector(nodeConnectorType, aDNodeConnectorId, aDNode);
 151     }
 152
 153     /**
 154      * @param ncid   nodeConnector identifier, e.g.: OF:21 or CTRL
 155      * @param aDNode
 156      * @return nodeConnector attached to given node
 157      * @throws ConstructionException
 158      */
 159     public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(
 160             final NodeConnectorId ncid, final org.opendaylight.controller.sal.core.Node aDNode) throws ConstructionException {
 161         NodeId nid = NodeMapping.toNodeId(aDNode);
 162         String nodeConnectorType = NodeMapping.toNodeConnectorType(ncid, nid);
 163         Object aDNodeConnectorId = NodeMapping.toADNodeConnectorId(ncid, nid);
 164         return new org.opendaylight.controller.sal.core.NodeConnector(nodeConnectorType, aDNodeConnectorId, aDNode);
 165     }
 166
 167     /**
 168      * @param aDNode
 169      * @return
 170      */
 171     public static NodeId toNodeId(org.opendaylight.controller.sal.core.Node aDNode) {
 172         String targetPrefix = null;
 173         if (NodeIDType.OPENFLOW.equals(aDNode.getType())) {
 174                 targetPrefix = OPENFLOW_ID_PREFIX;
 175         } else {
 176             targetPrefix = aDNode.getType() + ":";
 177         }
 178
 179         return new NodeId(targetPrefix + String.valueOf(aDNode.getID()));
 180     }
 181
 182     /**
 183      * @param aDNode
 184      * @return md-sal {@link NodeKey}
 185      */
 186     public static NodeKey toNodeKey(org.opendaylight.controller.sal.core.Node aDNode) {
 187         return new NodeKey(toNodeId(aDNode));
 188     }
 189
 190     public static String toNodeConnectorType(final NodeConnectorId ncId, final NodeId nodeId) {
 191         if (ncId.equals(toLocalNodeConnectorId(nodeId))) {
 192             return NodeConnectorIDType.SWSTACK;
 193         } else if (ncId.equals(toNormalNodeConnectorId(nodeId))) {
 194             return NodeConnectorIDType.HWPATH;
 195         } else if (ncId.equals(toControllerNodeConnectorId(nodeId))) {
 196             return NodeConnectorIDType.CONTROLLER;
 197         }
 198         return NodeConnectorIDType.OPENFLOW;
 199     }
 200
 201     public static Object toADNodeConnectorId(final NodeConnectorId nodeConnectorId, final NodeId nodeId) {
 202         if (nodeConnectorId.equals(toLocalNodeConnectorId(nodeId)) ||
 203                 nodeConnectorId.equals(toNormalNodeConnectorId(nodeId)) ||
 204                 nodeConnectorId.equals(toControllerNodeConnectorId(nodeId))) {
 205             return org.opendaylight.controller.sal.core.NodeConnector.SPECIALNODECONNECTORID;
 206         }
 207
 208         String nodeConnectorIdStripped = ALL_CHARS_TO_COLON.matcher(nodeConnectorId.getValue()).replaceFirst("");
 209
 210         if (NUMBERS_ONLY.matcher(nodeConnectorIdStripped).matches()) {
 211             Short nodeConnectorIdVal = null;
 212             try {
 213                 nodeConnectorIdVal = Short.valueOf(nodeConnectorIdStripped);
 214                 return nodeConnectorIdVal;
 215             } catch (NumberFormatException e) {
 216                 LOG.warn("nodeConnectorId not supported (long): {}", nodeConnectorIdStripped, e);
 217             }
 218         }
 219         return nodeConnectorIdStripped;
 220     }
 221
 222     public static NodeId toAdNodeId(final NodeConnectorId nodeConnectorId) {
 223         NodeId nodeId = null;
 224         if (nodeConnectorId != null) {
 225             nodeId = new NodeId(COLON_NUMBERS_EOL.matcher(nodeConnectorId.getValue()).replaceFirst(""));
 226         }
 227         return nodeId;
 228     }
 229
 230     public static NodeConnectorId toControllerNodeConnectorId(final NodeId node) {
 231         return new NodeConnectorId(node.getValue() + ":" + OutputPortValues.CONTROLLER.toString());
 232     }
 233
 234     public static NodeConnectorId toLocalNodeConnectorId(final NodeId node) {
 235         return new NodeConnectorId(node.getValue() + ":" + OutputPortValues.LOCAL.toString());
 236     }
 237
 238     public static NodeConnectorId toNormalNodeConnectorId(final NodeId node) {
 239         return new NodeConnectorId(node.getValue() + ":" + OutputPortValues.NORMAL.toString());
 240     }
 241
 242     public static NodeRef toNodeRef(final org.opendaylight.controller.sal.core.Node node) {
 243         Preconditions.checkArgument(NodeIDType.OPENFLOW.equals(node.getType()));
 244         final Long nodeId = Arguments.<Long>checkInstanceOf(node.getID(), Long.class);
 245         final NodeKey nodeKey = new NodeKey(new NodeId(OPENFLOW_ID_PREFIX + nodeId));
 246         final InstanceIdentifier<Node> nodePath = InstanceIdentifier.builder(Nodes.class).child(NODE_CLASS, nodeKey).toInstance();
 247         return new NodeRef(nodePath);
 248     }
 249
 250     public static NodeConnectorRef toNodeConnectorRef(final org.opendaylight.controller.sal.core.NodeConnector nodeConnector) {
 251
 252         final NodeRef node = NodeMapping.toNodeRef(nodeConnector.getNode());
 253         @SuppressWarnings("unchecked")
 254         final InstanceIdentifier<Node> nodePath = ((InstanceIdentifier<Node>) node.getValue());
 255         NodeConnectorId nodeConnectorId = null;
 256
 257         if (nodeConnector.getID().equals(org.opendaylight.controller.sal.core.NodeConnector.SPECIALNODECONNECTORID)) {
 258             final NodeId nodeId = toNodeId(nodePath);
 259             final String nodeConnectorType = nodeConnector.getType();
 260             if (nodeConnectorType.equals(NodeConnectorIDType.SWSTACK)) {
 261                 nodeConnectorId = toLocalNodeConnectorId(nodeId);
 262             } else if (nodeConnectorType.equals(NodeConnectorIDType.HWPATH)) {
 263                 nodeConnectorId = toNormalNodeConnectorId(nodeId);
 264             } else if (nodeConnectorType.equals(NodeConnectorIDType.CONTROLLER)) {
 265                 nodeConnectorId = toControllerNodeConnectorId(nodeId);
 266             }
 267         } else {
 268             nodeConnectorId = new NodeConnectorId(OPENFLOW_ID_PREFIX
 269                     + Arguments.<Short>checkInstanceOf(nodeConnector.getID(), Short.class));
 270         }
 271         final NodeConnectorKey connectorKey = new NodeConnectorKey(nodeConnectorId);
 272         final InstanceIdentifier<NodeConnector> path = nodePath.child(NODECONNECTOR_CLASS, connectorKey);
 273         return new NodeConnectorRef(path);
 274     }
 275
 276     public static org.opendaylight.controller.sal.core.Node toADNode(final NodeRef node) throws ConstructionException {
 277         return NodeMapping.toADNode(node.getValue());
 278     }
 279
 280     public static HashSet<Property> toADNodeConnectorProperties(final NodeConnectorUpdated nc) {
 281         final FlowCapableNodeConnectorUpdated fcncu = nc.<FlowCapableNodeConnectorUpdated>getAugmentation(FlowCapableNodeConnectorUpdated.class);
 282         if (!Objects.equal(fcncu, null)) {
 283             HashSet<Property> adNodeConnectorProperties = NodeMapping.toADNodeConnectorProperties(fcncu);
 284             return adNodeConnectorProperties;
 285         }
 286         return new HashSet<Property>();
 287     }
 288
 289     /**
 290      * @param nodeRef
 291      * @return node description in AD form, e.g.: OF|00:00:00:...:01
 292      */
 293     private static Description toADDescription(NodeRef nodeRef) {
 294         Description desc;
 295         try {
 296             desc = new Description(toADNode(nodeRef).toString());
 297         } catch (ConstructionException e) {
 298             desc = new Description("none");
 299             LOG.warn("node description extraction failed: {}", nodeRef);
 300         }
 301         return desc;
 302     }
 303
 304     public static HashSet<Property> toADNodeConnectorProperties(final NodeConnector nc) {
 305         final FlowCapableNodeConnector fcnc = nc.<FlowCapableNodeConnector>getAugmentation(FlowCapableNodeConnector.class);
 306         if (!Objects.equal(fcnc, null)) {
 307             return NodeMapping.toADNodeConnectorProperties(fcnc);
 308         }
 309         return new HashSet<Property>();
 310     }
 311
 312     public static HashSet<Property> toADNodeConnectorProperties(final FlowNodeConnector fcncu) {
 313
 314         final HashSet<org.opendaylight.controller.sal.core.Property> props = new HashSet<>();
 315         if (fcncu != null) {
 316             if (fcncu.getCurrentFeature() != null && toAdBandwidth(fcncu.getCurrentFeature()) != null) {
 317                 props.add(toAdBandwidth(fcncu.getCurrentFeature()));
 318             }
 319             if (fcncu.getAdvertisedFeatures() != null && toAdAdvertizedBandwidth(fcncu.getAdvertisedFeatures()) != null) {
 320                 props.add(toAdAdvertizedBandwidth(fcncu.getAdvertisedFeatures()));
 321             }
 322             if (fcncu.getSupported() != null && toAdSupportedBandwidth(fcncu.getSupported()) != null) {
 323                 props.add(toAdSupportedBandwidth(fcncu.getSupported()));
 324             }
 325             if (fcncu.getPeerFeatures() != null && toAdPeerBandwidth(fcncu.getPeerFeatures()) != null) {
 326                 props.add(toAdPeerBandwidth(fcncu.getPeerFeatures()));
 327             }
 328             if (fcncu.getName() != null && toAdName(fcncu.getName()) != null) {
 329                 props.add(toAdName(fcncu.getName()));
 330             }
 331             if (fcncu.getConfiguration() != null && toAdConfig(fcncu.getConfiguration()) != null) {
 332                 props.add(toAdConfig(fcncu.getConfiguration()));
 333             }
 334             if (fcncu.getState() != null && toAdState(fcncu.getState()) != null) {
 335                 props.add(toAdState(fcncu.getState()));
 336             }
 337         }
 338         return props;
 339     }
 340
 341     public static Name toAdName(final String name) {
 342         return new Name(name);
 343     }
 344
 345     public static Config toAdConfig(final PortConfig pc) {
 346         Config config = null;
 347         if (pc.isPORTDOWN()) {
 348             config = new Config(Config.ADMIN_DOWN);
 349         } else {
 350             config = new Config(Config.ADMIN_UP);
 351         }
 352         return config;
 353     }
 354
 355     public static org.opendaylight.controller.sal.core.State toAdState(final State s) {
 356
 357         org.opendaylight.controller.sal.core.State state = null;
 358         if (s.isLinkDown()) {
 359             state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_DOWN);
 360         } else {
 361             state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_UP);
 362         }
 363         return state;
 364     }
 365
 366     public static Bandwidth toAdBandwidth(final PortFeatures pf) {
 367         Bandwidth bw = null;
 368         if (pf.isTenMbHd() || pf.isTenMbFd()) {
 369             bw = new Bandwidth(Bandwidth.BW10Mbps);
 370         } else if (pf.isHundredMbHd() || pf.isHundredMbFd()) {
 371             bw = new Bandwidth(Bandwidth.BW100Mbps);
 372         } else if (pf.isOneGbHd() || pf.isOneGbFd()) {
 373             bw = new Bandwidth(Bandwidth.BW1Gbps);
 374         } else if (pf.isOneGbFd()) {
 375             bw = new Bandwidth(Bandwidth.BW10Gbps);
 376         } else if (pf.isTenGbFd()) {
 377             bw = new Bandwidth(Bandwidth.BW10Gbps);
 378         } else if (pf.isFortyGbFd()) {
 379             bw = new Bandwidth(Bandwidth.BW40Gbps);
 380         } else if (pf.isHundredGbFd()) {
 381             bw = new Bandwidth(Bandwidth.BW100Gbps);
 382         } else if (pf.isOneTbFd()) {
 383             bw = new Bandwidth(Bandwidth.BW1Tbps);
 384         }
 385         return bw;
 386     }
 387
 388     public static AdvertisedBandwidth toAdAdvertizedBandwidth(final PortFeatures pf) {
 389         AdvertisedBandwidth abw = null;
 390         final Bandwidth bw = toAdBandwidth(pf);
 391         if (bw != null) {
 392             abw = new AdvertisedBandwidth(bw.getValue());
 393         }
 394         return abw;
 395     }
 396
 397     public static SupportedBandwidth toAdSupportedBandwidth(final PortFeatures pf) {
 398         SupportedBandwidth sbw = null;
 399         final Bandwidth bw = toAdBandwidth(pf);
 400         if (bw != null) {
 401             sbw = new SupportedBandwidth(bw.getValue());
 402         }
 403         return sbw;
 404     }
 405
 406     public static PeerBandwidth toAdPeerBandwidth(final PortFeatures pf) {
 407         PeerBandwidth pbw = null;
 408         final Bandwidth bw = toAdBandwidth(pf);
 409         if (bw != null) {
 410             pbw = new PeerBandwidth(bw.getValue());
 411         }
 412         return pbw;
 413     }
 414
 415     public static HashSet<Property> toADNodeProperties(final NodeUpdated nu) {
 416         final FlowCapableNodeUpdated fcnu = nu.getAugmentation(FlowCapableNodeUpdated.class);
 417         if (fcnu != null) {
 418             HashSet<Property> adNodeProperties = toADNodeProperties(fcnu, nu.getId());
 419             adNodeProperties.add(toADDescription(nu.getNodeRef()));
 420             return adNodeProperties;
 421         }
 422         return new HashSet<org.opendaylight.controller.sal.core.Property>();
 423     }
 424
 425     public static HashSet<Property> toADNodeProperties(final FlowNode fcnu, final NodeId id) {
 426
 427         final HashSet<org.opendaylight.controller.sal.core.Property> props = new HashSet<>();
 428
 429         if (fcnu != null) {
 430             props.add(toADTimestamp());
 431
 432             // props.add(fcnu.supportedActions.toADActions) - TODO
 433             if (id != null) {
 434                 props.add(toADMacAddress(id));
 435             }
 436             SwitchFeatures switchFeatures = fcnu.getSwitchFeatures();
 437             if (switchFeatures != null) {
 438                 if (switchFeatures.getMaxTables() != null) {
 439                     props.add(toADTables(switchFeatures.getMaxTables()));
 440                 }
 441                 if (switchFeatures.getCapabilities() != null) {
 442                     props.add(toADCapabiliities(switchFeatures.getCapabilities()));
 443                 }
 444                 if (switchFeatures.getMaxBuffers() != null) {
 445                     props.add(toADBuffers(switchFeatures.getMaxBuffers()));
 446                 }
 447             }
 448         }
 449         return props;
 450     }
 451
 452     public static TimeStamp toADTimestamp() {
 453         final Date date = new Date();
 454         final TimeStamp timestamp = new TimeStamp(date.getTime(), "connectedSince");
 455         return timestamp;
 456     }
 457
 458     public static MacAddress toADMacAddress(final NodeId id) {
 459         final String nodeId = id.getValue().replaceAll(OPENFLOW_ID_PREFIX, "");
 460         BigInteger nodeIdRaw = new BigInteger(nodeId);
 461         long lNodeId = nodeIdRaw.longValue();
 462         byte[] bytesFromDpid = ToSalConversionsUtils.bytesFromDpid(lNodeId);
 463         return new MacAddress(bytesFromDpid);
 464     }
 465
 466     public static Tables toADTables(final Short tables) {
 467         return new Tables(tables.byteValue());
 468     }
 469
 470     public static Capabilities toADCapabiliities(final List<Class<? extends FeatureCapability>> capabilities) {
 471
 472         int b = 0;
 473         for (Class<? extends FeatureCapability> capability : capabilities) {
 474             if (capability.equals(FlowFeatureCapabilityFlowStats.class)) {
 475                 b = Capabilities.CapabilitiesType.FLOW_STATS_CAPABILITY.getValue() | b;
 476             } else if (capability.equals(FlowFeatureCapabilityTableStats.class)) {
 477                 b = Capabilities.CapabilitiesType.TABLE_STATS_CAPABILITY.getValue() | b;
 478             } else if (capability.equals(FlowFeatureCapabilityPortStats.class)) {
 479                 b = Capabilities.CapabilitiesType.PORT_STATS_CAPABILITY.getValue() | b;
 480             } else if (capability.equals(FlowFeatureCapabilityStp.class)) {
 481                 b = Capabilities.CapabilitiesType.STP_CAPABILITY.getValue() | b;
 482             } else if (capability.equals(FlowFeatureCapabilityIpReasm.class)) {
 483                 b = Capabilities.CapabilitiesType.IP_REASSEM_CAPABILITY.getValue() | b;
 484             } else if (capability.equals(FlowFeatureCapabilityQueueStats.class)) {
 485                 b = Capabilities.CapabilitiesType.QUEUE_STATS_CAPABILITY.getValue() | b;
 486             } else if (capability.equals(FlowFeatureCapabilityArpMatchIp.class)) {
 487                 b = Capabilities.CapabilitiesType.ARP_MATCH_IP_CAPABILITY.getValue() | b;
 488             }
 489         }
 490         return new Capabilities(b);
 491     }
 492
 493     public static Buffers toADBuffers(final Long buffers) {
 494         return new Buffers(buffers.intValue());
 495     }
 496
 497
 498     private static final boolean isInteger(String value) {
 499         if (value.isEmpty()) return false;
 500         for (int i = 0; i < value.length(); i++) {
 501             if (i == 0 && value.charAt(i) == '-') {
 502                 if (value.length() == 1) return false;
 503                 else continue;
 504             }
 505             if (Character.digit(value.charAt(i), 10) < 0) return false;
 506         }
 507         return true;
 508     }
 509 }