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
  11 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
  12 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef
  13 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId
  14 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey
  15 import org.opendaylight.controller.sal.core.ConstructionException
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorUpdated
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortFeatures
  22 import org.opendaylight.controller.sal.core.Bandwidth
  23 import org.opendaylight.controller.sal.core.AdvertisedBandwidth
  24 import org.opendaylight.controller.sal.core.SupportedBandwidth
  25 import org.opendaylight.controller.sal.core.PeerBandwidth
  26 import org.opendaylight.controller.sal.core.Name
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortConfig
  28 import org.opendaylight.controller.sal.core.Config
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.flow.capable.port.State
  30
  31 public class NodeMapping {
  32
  33     public static val MD_SAL_TYPE = "MD_SAL";
  34     private static val NODE_CLASS = org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  35     private static val NODECONNECTOR_CLASS = org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  36
  37
  38     private new() {
  39         throw new UnsupportedOperationException("Utility class. Instantiation is not allowed.");
  40     }
  41
  42     public static def toADNode(InstanceIdentifier<?> node) throws ConstructionException {
  43         return new Node(MD_SAL_TYPE, node.toNodeId.toADNodeId);
  44     }
  45
  46     public static def toNodeId(InstanceIdentifier<?> node) {
  47         checkNotNull(node);
  48         checkNotNull(node.getPath());
  49         checkArgument(node.getPath().size() >= 2);
  50         val arg = node.getPath().get(1);
  51         val item = arg.checkInstanceOf(IdentifiableItem);
  52         val nodeKey = item.getKey().checkInstanceOf(NodeKey);
  53         return nodeKey.id
  54     }
  55
  56     public static def toADNodeId(NodeId nodeId) {
  57         checkNotNull(nodeId);
  58         return nodeId.value
  59     }
  60
  61
  62     public static def toADNodeConnector(NodeConnectorRef source) throws ConstructionException {
  63         checkNotNull(source);
  64         val InstanceIdentifier<?> path = checkNotNull(source.getValue());
  65         val node = path.toADNode();
  66         checkArgument(path.path.size() >= 3);
  67         val arg = path.getPath().get(2);
  68         val item = arg.checkInstanceOf(IdentifiableItem);
  69         val connectorKey = item.getKey().checkInstanceOf(NodeConnectorKey);
  70         return new NodeConnector(connectorKey.id.toNodeConnectorType(path.toNodeId), connectorKey.id.toADNodeConnectorId(path.toNodeId), node);
  71     }
  72
  73     public static def toNodeConnectorType(NodeConnectorId ncId,NodeId nodeId) {
  74         if (ncId.equals(nodeId.toLocalNodeConnectorId)) {
  75             return NodeConnector.NodeConnectorIDType.SWSTACK
  76         } else if (ncId.equals(nodeId.toNormalNodeConnectorId)) {
  77             return NodeConnector.NodeConnectorIDType.HWPATH
  78         } else if (ncId.equals(nodeId.toControllerNodeConnectorId)){
  79             return NodeConnector.NodeConnectorIDType.CONTROLLER
  80         }
  81         return MD_SAL_TYPE
  82     }
  83
  84     public static def toADNodeConnectorId(NodeConnectorId nodeConnectorId,NodeId nodeId) {
  85         if(nodeConnectorId.equals(nodeId.toLocalNodeConnectorId) ||
  86             nodeConnectorId.equals(nodeId.toNormalNodeConnectorId) ||
  87             nodeConnectorId.equals(nodeId.toControllerNodeConnectorId)
  88         ) {
  89             return NodeConnector.SPECIALNODECONNECTORID
  90         }
  91         return nodeConnectorId.value
  92     }
  93
  94     public static def  toControllerNodeConnectorId(NodeId node) {
  95         return new NodeConnectorId(node.value + ":" + 4294967293L)
  96     }
  97     public static def  toLocalNodeConnectorId(NodeId node) {
  98         return new NodeConnectorId(node.value + ":" + 4294967294L)
  99     }
 100     public static def  toNormalNodeConnectorId(NodeId node) {
 101         return new NodeConnectorId(node.value + ":" + 4294967290L)
 102     }
 103
 104     public static def toNodeRef(Node node) {
 105         checkArgument(MD_SAL_TYPE.equals(node.getType()));
 106         var nodeId = node.ID.checkInstanceOf(String)
 107         val nodeKey = new NodeKey(new NodeId(nodeId));
 108         val nodePath = InstanceIdentifier.builder().node(Nodes).child(NODE_CLASS, nodeKey).toInstance();
 109         return new NodeRef(nodePath);
 110     }
 111
 112     public static def toNodeConnectorRef(NodeConnector nodeConnector) {
 113         val node = nodeConnector.node.toNodeRef();
 114         val nodePath = node.getValue() as InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node>
 115         var NodeConnectorId nodeConnectorId
 116         if(nodeConnector.ID.equals(NodeConnector.SPECIALNODECONNECTORID)){
 117             if(nodeConnector.type.equals(NodeConnector.NodeConnectorIDType.SWSTACK)) {
 118                 nodeConnectorId = nodePath.toNodeId.toLocalNodeConnectorId
 119             } else if (nodeConnector.type.equals(NodeConnector.NodeConnectorIDType.HWPATH)) {
 120                 nodeConnectorId = nodePath.toNodeId.toNormalNodeConnectorId
 121             } else if (nodeConnector.type.equals(NodeConnector.NodeConnectorIDType.CONTROLLER)) {
 122                 nodeConnectorId = nodePath.toNodeId.toControllerNodeConnectorId
 123             }
 124         } else {
 125             nodeConnectorId = new NodeConnectorId(nodeConnector.ID.checkInstanceOf(String))
 126         }
 127         val connectorKey = new NodeConnectorKey(nodeConnectorId);
 128         val path = InstanceIdentifier.builder(nodePath).child(NODECONNECTOR_CLASS, connectorKey).toInstance();
 129         return new NodeConnectorRef(path);
 130     }
 131
 132     public static def toADNode(NodeRef node) throws ConstructionException {
 133         return toADNode(node.getValue());
 134     }
 135
 136     public static def toADNodeConnectorProperties(NodeConnectorUpdated nc) {
 137         val props = new java.util.HashSet<org.opendaylight.controller.sal.core.Property>();
 138         val fcncu = nc.getAugmentation(FlowCapableNodeConnectorUpdated)
 139         if(fcncu != null) {
 140             if(fcncu.currentFeature != null && fcncu.currentFeature.toAdBandwidth != null) {
 141                 props.add(fcncu.currentFeature.toAdBandwidth)
 142             }
 143             if(fcncu.advertisedFeatures != null && fcncu.advertisedFeatures.toAdAdvertizedBandwidth != null) {
 144                 props.add(fcncu.advertisedFeatures.toAdAdvertizedBandwidth)
 145             }
 146             if(fcncu.supported != null && fcncu.supported.toAdSupportedBandwidth != null) {
 147                 props.add(fcncu.supported.toAdSupportedBandwidth)
 148             }
 149             if(fcncu.peerFeatures != null && fcncu.peerFeatures.toAdPeerBandwidth != null) {
 150                 props.add(fcncu.peerFeatures.toAdPeerBandwidth)
 151             }
 152             if(fcncu.name != null && fcncu.name.toAdName != null) {
 153                 props.add(fcncu.name.toAdName)
 154             }
 155             if(fcncu.configuration != null && fcncu.configuration.toAdConfig != null) {
 156                 props.add(fcncu.configuration.toAdConfig)
 157             }
 158             if(fcncu.state != null && fcncu.state.toAdState != null) {
 159                 props.add(fcncu.state.toAdState)
 160             }
 161         }
 162         return props
 163     }
 164
 165     public static def toAdName(String name) {
 166         return new Name(name)
 167     }
 168
 169     public static def toAdConfig(PortConfig pc) {
 170         var Config config;
 171         if(pc.PORTDOWN){
 172             config = new Config(Config.ADMIN_DOWN)
 173         } else {
 174             config = new Config(Config.ADMIN_UP)
 175         }
 176         return config
 177     }
 178
 179     public static def toAdState(State s) {
 180         var org.opendaylight.controller.sal.core.State state
 181         if(s.linkDown) {
 182             state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_DOWN)
 183         } else {
 184             state = new org.opendaylight.controller.sal.core.State(org.opendaylight.controller.sal.core.State.EDGE_UP)
 185         }
 186         return state
 187     }
 188
 189     public static def toAdBandwidth(PortFeatures pf) {
 190         var Bandwidth bw = null
 191         if (pf.is_10mbHd || pf.is_10mbFd ) {
 192             bw= new Bandwidth(Bandwidth.BW10Mbps)
 193         } else if (pf.is_100mbHd || pf.is_100mbFd ) {
 194             bw= new Bandwidth(Bandwidth.BW100Mbps)
 195         } else if (pf.is_1gbHd || pf.is_1gbFd ) {
 196             bw= new Bandwidth(Bandwidth.BW1Gbps)
 197         } else if (pf.is_1gbFd ) {
 198             bw= new Bandwidth(Bandwidth.BW10Gbps)
 199         } else if ( pf.is_10gbFd ) {
 200             bw= new Bandwidth(Bandwidth.BW10Gbps)
 201         } else if ( pf.is_40gbFd ) {
 202             bw= new Bandwidth(Bandwidth.BW40Gbps)
 203         } else if ( pf.is_100gbFd ) {
 204             bw= new Bandwidth(Bandwidth.BW100Gbps)
 205         } else if ( pf.is_1tbFd ) {
 206             bw= new Bandwidth(Bandwidth.BW1Tbps)
 207         }
 208         return bw;
 209     }
 210
 211     public static def toAdAdvertizedBandwidth(PortFeatures pf) {
 212         var AdvertisedBandwidth abw
 213         val bw = pf.toAdBandwidth
 214         if(bw != null) {
 215             abw = new AdvertisedBandwidth(bw.value)
 216         }
 217         return abw
 218     }
 219
 220     public static def toAdSupportedBandwidth(PortFeatures pf) {
 221         var SupportedBandwidth sbw
 222         val bw = pf.toAdBandwidth
 223         if(bw != null ) {
 224             sbw = new SupportedBandwidth(bw.value)
 225         }
 226         return sbw
 227     }
 228
 229     public static def toAdPeerBandwidth(PortFeatures pf) {
 230         var PeerBandwidth pbw
 231         val bw = pf.toAdBandwidth
 232         if(bw != null) {
 233             pbw = new PeerBandwidth(bw.value)
 234         }
 235         return pbw
 236     }
 237
 238
 239 }