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

   1 package org.opendaylight.controller.sal.compatibility
   2
   3 import org.opendaylight.controller.sal.core.Node
   4 import org.opendaylight.controller.sal.core.NodeConnector
   5 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey
   6 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem
   7
   8 import static com.google.common.base.Preconditions.*;
   9 import static extension org.opendaylight.controller.sal.common.util.Arguments.*;
  10 import static extension org.opendaylight.controller.sal.compatibility.ToSalConversionsUtils.*;
  11
  12 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
  13 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef
  14 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId
  15 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey
  16 import org.opendaylight.controller.sal.core.ConstructionException
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorUpdated
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortFeatures
  23 import org.opendaylight.controller.sal.core.Bandwidth
  24 import org.opendaylight.controller.sal.core.AdvertisedBandwidth
  25 import org.opendaylight.controller.sal.core.SupportedBandwidth
  26 import org.opendaylight.controller.sal.core.PeerBandwidth
  27 import org.opendaylight.controller.sal.core.Name
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortConfig
  29 import org.opendaylight.controller.sal.core.Config
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.flow.capable.port.State
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated
  32 import java.util.HashSet
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated
  34 import org.opendaylight.controller.sal.core.Tables
  35 import java.util.List
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FeatureCapability
  37 import org.opendaylight.controller.sal.core.Buffers
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityFlowStats
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityTableStats
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityIpReasm
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityPortStats
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityStp
  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.FlowFeatureCapabilityArpMatchIp
  45 import org.opendaylight.controller.sal.core.Capabilities
  46 import org.opendaylight.controller.sal.core.MacAddress
  47 import java.util.Date
  48 import org.opendaylight.controller.sal.core.TimeStamp
  49
  50 public class NodeMapping {
  51
  52     public static val MD_SAL_TYPE = "MD_SAL";
  53     private static val NODE_CLASS = org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  54     private static val NODECONNECTOR_CLASS = org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  55
  56
  57     private new() {
  58         throw new UnsupportedOperationException("Utility class. Instantiation is not allowed.");
  59     }
  60
  61     public static def toADNode(InstanceIdentifier<?> node) throws ConstructionException {
  62         return new Node(MD_SAL_TYPE, node.toNodeId.toADNodeId);
  63     }
  64
  65     public static def toNodeId(InstanceIdentifier<?> node) {
  66         checkNotNull(node);
  67         checkNotNull(node.getPath());
  68         checkArgument(node.getPath().size() >= 2);
  69         val arg = node.getPath().get(1);
  70         val item = arg.checkInstanceOf(IdentifiableItem);
  71         val nodeKey = item.getKey().checkInstanceOf(NodeKey);
  72         return nodeKey.id
  73     }
  74
  75     public static def toADNodeId(NodeId nodeId) {
  76         checkNotNull(nodeId);
  77         return nodeId.value
  78     }
  79
  80
  81     public static def toADNodeConnector(NodeConnectorRef source) throws ConstructionException {
  82         checkNotNull(source);
  83         val InstanceIdentifier<?> path = checkNotNull(source.getValue());
  84         val node = path.toADNode();
  85         checkArgument(path.path.size() >= 3);
  86         val arg = path.getPath().get(2);
  87         val item = arg.checkInstanceOf(IdentifiableItem);
  88         val connectorKey = item.getKey().checkInstanceOf(NodeConnectorKey);
  89         return new NodeConnector(connectorKey.id.toNodeConnectorType(path.toNodeId), connectorKey.id.toADNodeConnectorId(path.toNodeId), node);
  90     }
  91
  92     public static def toNodeConnectorType(NodeConnectorId ncId,NodeId nodeId) {
  93         if (ncId.equals(nodeId.toLocalNodeConnectorId)) {
  94             return NodeConnector.NodeConnectorIDType.SWSTACK
  95         } else if (ncId.equals(nodeId.toNormalNodeConnectorId)) {
  96             return NodeConnector.NodeConnectorIDType.HWPATH
  97         } else if (ncId.equals(nodeId.toControllerNodeConnectorId)){
  98             return NodeConnector.NodeConnectorIDType.CONTROLLER
  99         }
 100         return MD_SAL_TYPE
 101     }
 102
 103     public static def toADNodeConnectorId(NodeConnectorId nodeConnectorId,NodeId nodeId) {
 104         if(nodeConnectorId.equals(nodeId.toLocalNodeConnectorId) ||
 105             nodeConnectorId.equals(nodeId.toNormalNodeConnectorId) ||
 106             nodeConnectorId.equals(nodeId.toControllerNodeConnectorId)
 107         ) {
 108             return NodeConnector.SPECIALNODECONNECTORID
 109         }
 110         return nodeConnectorId.value
 111     }
 112
 113     public static def  toControllerNodeConnectorId(NodeId node) {
 114         return new NodeConnectorId(node.value + ":" + 4294967293L)
 115     }
 116     public static def  toLocalNodeConnectorId(NodeId node) {
 117         return new NodeConnectorId(node.value + ":" + 4294967294L)
 118     }
 119     public static def  toNormalNodeConnectorId(NodeId node) {
 120         return new NodeConnectorId(node.value + ":" + 4294967290L)
 121     }
 122
 123     public static def toNodeRef(Node node) {
 124         checkArgument(MD_SAL_TYPE.equals(node.getType()));
 125         var nodeId = node.ID.checkInstanceOf(String)
 126         val nodeKey = new NodeKey(new NodeId(nodeId));
 127         val nodePath = InstanceIdentifier.builder().node(Nodes).child(NODE_CLASS, nodeKey).toInstance();
 128         return new NodeRef(nodePath);
 129     }
 130
 131     public static def toNodeConnectorRef(NodeConnector nodeConnector) {
 132         val node = nodeConnector.node.toNodeRef();
 133         val nodePath = node.getValue() as InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node>
 134         var NodeConnectorId nodeConnectorId
 135         if(nodeConnector.ID.equals(NodeConnector.SPECIALNODECONNECTORID)){
 136             if(nodeConnector.type.equals(NodeConnector.NodeConnectorIDType.SWSTACK)) {
 137                 nodeConnectorId = nodePath.toNodeId.toLocalNodeConnectorId
 138             } else if (nodeConnector.type.equals(NodeConnector.NodeConnectorIDType.HWPATH)) {
 139                 nodeConnectorId = nodePath.toNodeId.toNormalNodeConnectorId
 140             } else if (nodeConnector.type.equals(NodeConnector.NodeConnectorIDType.CONTROLLER)) {
 141                 nodeConnectorId = nodePath.toNodeId.toControllerNodeConnectorId
 142             }
 143         } else {
 144             nodeConnectorId = new NodeConnectorId(nodeConnector.ID.checkInstanceOf(String))
 145         }
 146         val connectorKey = new NodeConnectorKey(nodeConnectorId);
 147         val path = InstanceIdentifier.builder(nodePath).child(NODECONNECTOR_CLASS, connectorKey).toInstance();
 148         return new NodeConnectorRef(path);
 149     }
 150
 151     public static def toADNode(NodeRef node) throws ConstructionException {
 152         return toADNode(node.getValue());
 153     }
 154
 155     public static def toADNodeConnectorProperties(NodeConnectorUpdated nc) {
 156         val props = new HashSet<org.opendaylight.controller.sal.core.Property>();
 157         val fcncu = nc.getAugmentation(FlowCapableNodeConnectorUpdated)
 158         if(fcncu != null) {
 159             if(fcncu.currentFeature != null && fcncu.currentFeature.toAdBandwidth != null) {
 160                 props.add(fcncu.currentFeature.toAdBandwidth)
 161             }
 162             if(fcncu.advertisedFeatures != null && fcncu.advertisedFeatures.toAdAdvertizedBandwidth != null) {
 163                 props.add(fcncu.advertisedFeatures.toAdAdvertizedBandwidth)
 164             }
 165             if(fcncu.supported != null && fcncu.supported.toAdSupportedBandwidth != null) {
 166                 props.add(fcncu.supported.toAdSupportedBandwidth)
 167             }
 168             if(fcncu.peerFeatures != null && fcncu.peerFeatures.toAdPeerBandwidth != null) {
 169                 props.add(fcncu.peerFeatures.toAdPeerBandwidth)
 170             }
 171             if(fcncu.name != null && fcncu.name.toAdName != null) {
 172                 props.add(fcncu.name.toAdName)
 173             }
 174             if(fcncu.configuration != null && fcncu.configuration.toAdConfig != null) {
 175                 props.add(fcncu.configuration.toAdConfig)
 176             }
 177             if(fcncu.state != null && fcncu.state.toAdState != null) {
 178                 props.add(fcncu.state.toAdState)
 179             }
 180         }
 181         return props
 182     }
 183
 184     public static def toAdName(String name) {
 185         return new Name(name)
 186     }
 187
 188     public static def toAdConfig(PortConfig pc) {
 189         var Config config;
 190         if(pc.PORTDOWN){
 191             config = new Config(Config.ADMIN_DOWN)
 192         } else {
 193             config = new Config(Config.ADMIN_UP)
 194         }
 195         return config
 196     }
 197
 198     public static def toAdState(State s) {
 199         var org.opendaylight.controller.sal.core.State state
 200         if(s.linkDown) {
 201             state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_DOWN)
 202         } else {
 203             state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_UP)
 204         }
 205         return state
 206     }
 207
 208     public static def toAdBandwidth(PortFeatures pf) {
 209         var Bandwidth bw = null
 210         if (pf.is_10mbHd || pf.is_10mbFd ) {
 211             bw= new Bandwidth(Bandwidth.BW10Mbps)
 212         } else if (pf.is_100mbHd || pf.is_100mbFd ) {
 213             bw= new Bandwidth(Bandwidth.BW100Mbps)
 214         } else if (pf.is_1gbHd || pf.is_1gbFd ) {
 215             bw= new Bandwidth(Bandwidth.BW1Gbps)
 216         } else if (pf.is_1gbFd ) {
 217             bw= new Bandwidth(Bandwidth.BW10Gbps)
 218         } else if ( pf.is_10gbFd ) {
 219             bw= new Bandwidth(Bandwidth.BW10Gbps)
 220         } else if ( pf.is_40gbFd ) {
 221             bw= new Bandwidth(Bandwidth.BW40Gbps)
 222         } else if ( pf.is_100gbFd ) {
 223             bw= new Bandwidth(Bandwidth.BW100Gbps)
 224         } else if ( pf.is_1tbFd ) {
 225             bw= new Bandwidth(Bandwidth.BW1Tbps)
 226         }
 227         return bw;
 228     }
 229
 230     public static def toAdAdvertizedBandwidth(PortFeatures pf) {
 231         var AdvertisedBandwidth abw
 232         val bw = pf.toAdBandwidth
 233         if(bw != null) {
 234             abw = new AdvertisedBandwidth(bw.value)
 235         }
 236         return abw
 237     }
 238
 239     public static def toAdSupportedBandwidth(PortFeatures pf) {
 240         var SupportedBandwidth sbw
 241         val bw = pf.toAdBandwidth
 242         if(bw != null ) {
 243             sbw = new SupportedBandwidth(bw.value)
 244         }
 245         return sbw
 246     }
 247
 248     public static def toAdPeerBandwidth(PortFeatures pf) {
 249         var PeerBandwidth pbw
 250         val bw = pf.toAdBandwidth
 251         if(bw != null) {
 252             pbw = new PeerBandwidth(bw.value)
 253         }
 254         return pbw
 255     }
 256
 257     public static def toADNodeProperties(NodeUpdated nu) {
 258         val props = new HashSet<org.opendaylight.controller.sal.core.Property>();
 259         val fcnu = nu.getAugmentation(FlowCapableNodeUpdated)
 260         if(fcnu != null) {
 261              props.add(toADTimestamp)
 262              // props.add(fcnu.supportedActions.toADActions) - TODO
 263              if(nu.id != null) {
 264                 props.add(nu.id.toADMacAddress)
 265              }
 266              if(fcnu.switchFeatures != null) {
 267                  if(fcnu.switchFeatures.maxTables != null) {
 268                     props.add(fcnu.switchFeatures.maxTables.toADTables)
 269                  }
 270                  if(fcnu.switchFeatures.capabilities != null) {
 271                     props.add(fcnu.switchFeatures.capabilities.toADCapabiliities)
 272                  }
 273                  if(fcnu.switchFeatures.maxBuffers != null) {
 274                     props.add(fcnu.switchFeatures.maxBuffers.toADBuffers)
 275                  }
 276              }
 277         }
 278         return props;
 279
 280     }
 281
 282     public static def toADTimestamp() {
 283         val date = new Date();
 284         val timestamp = new TimeStamp(date.time,"connectedSince")
 285         return timestamp;
 286     }
 287
 288     public static def toADMacAddress(NodeId id) {
 289         return new MacAddress(Long.parseLong(id.value.replaceAll("openflow:","")).longValue.bytesFromDpid)
 290     }
 291
 292     public static def toADTables(Short tables) {
 293         return new Tables(tables.byteValue)
 294     }
 295
 296     public static def toADCapabiliities(List<Class<? extends FeatureCapability>> capabilities) {
 297         var int b
 298         for(capability : capabilities) {
 299             if(capability.equals(FlowFeatureCapabilityFlowStats)) {
 300                 b = Capabilities.CapabilitiesType.FLOW_STATS_CAPABILITY.value.bitwiseOr(b)
 301             } else if (capability.equals(FlowFeatureCapabilityTableStats)) {
 302                 b = Capabilities.CapabilitiesType.TABLE_STATS_CAPABILITY.value.bitwiseOr(b)
 303             } else if (capability.equals(FlowFeatureCapabilityPortStats)) {
 304                 b = Capabilities.CapabilitiesType.PORT_STATS_CAPABILITY.value.bitwiseOr(b)
 305             } else if (capability.equals(FlowFeatureCapabilityStp)) {
 306                 b = Capabilities.CapabilitiesType.STP_CAPABILITY.value.bitwiseOr(b)
 307             } else if (capability.equals(FlowFeatureCapabilityIpReasm)) {
 308                 b = Capabilities.CapabilitiesType.IP_REASSEM_CAPABILITY.value.bitwiseOr(b)
 309             } else if (capability.equals(FlowFeatureCapabilityQueueStats)) {
 310                 b = Capabilities.CapabilitiesType.QUEUE_STATS_CAPABILITY.value.bitwiseOr(b)
 311             } else if (capability.equals(FlowFeatureCapabilityArpMatchIp)) {
 312                 b = Capabilities.CapabilitiesType.ARP_MATCH_IP_CAPABILITY.value.bitwiseOr(b)
 313             }
 314         }
 315         return new Capabilities(b)
 316     }
 317
 318     public static def toADBuffers(Long buffers) {
 319         return new Buffers(buffers.intValue)
 320     }
 321
 322 }