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