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