opendaylight/md-sal/compatibility/inventory-topology-compatibility/src/main/java/org/opendaylight/controller/md/compatibility/switchmanager/CompatibleSwitchManager.xtend

   1 package org.opendaylight.controller.md.compatibility.switchmanager
   2
   3 import org.opendaylight.controller.switchmanager.ISwitchManager
   4 import org.opendaylight.controller.sal.core.NodeConnector
   5 import org.opendaylight.controller.sal.core.Property
   6 import java.util.List
   7 import org.opendaylight.controller.sal.core.Node
   8 import java.net.InetAddress
   9 import org.opendaylight.controller.sal.binding.api.data.DataBrokerService
  10 import static extension org.opendaylight.controller.sal.compatibility.NodeMapping.*
  11 import org.opendaylight.controller.sal.core.Description
  12 import org.opendaylight.controller.sal.core.Tier
  13 import org.opendaylight.controller.sal.core.Bandwidth
  14 import org.opendaylight.controller.sal.core.ForwardingMode
  15 import org.opendaylight.controller.sal.core.MacAddress
  16
  17 import org.slf4j.LoggerFactory
  18 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
  19 import org.opendaylight.yangtools.yang.binding.DataObject
  20 import java.net.NetworkInterface
  21 import java.net.SocketException
  22 import java.util.Collections
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes
  24 import java.util.ArrayList
  25 import org.opendaylight.controller.switchmanager.Switch
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId
  28 import java.util.Map
  29 import java.util.HashSet
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortState
  32
  33 class CompatibleSwitchManager extends ConfigurableSwitchManager implements ISwitchManager {
  34
  35     private static val log = LoggerFactory.getLogger(CompatibleSwitchManager)
  36
  37     @org.eclipse.xtend.lib.Property
  38     var DataBrokerService dataService;
  39
  40     override addNodeConnectorProp(NodeConnector nodeConnector, Property prop) {
  41         val it = dataService.beginTransaction
  42         val path = nodeConnector.toNodeConnectorRef
  43
  44         // TODO: Update FlowCapableNode
  45         return null;
  46     }
  47
  48     override createProperty(String propName, String propValue) {
  49         try {
  50             if (propName.equalsIgnoreCase(Description.propertyName)) {
  51                 return new Description(propValue);
  52             } else if (propName.equalsIgnoreCase(Tier.TierPropName)) {
  53                 val tier = Integer.parseInt(propValue);
  54                 return new Tier(tier);
  55             } else if (propName.equalsIgnoreCase(Bandwidth.BandwidthPropName)) {
  56                 val bw = Long.parseLong(propValue);
  57                 return new Bandwidth(bw);
  58             } else if (propName.equalsIgnoreCase(ForwardingMode.name)) {
  59                 val mode = Integer.parseInt(propValue);
  60                 return new ForwardingMode(mode);
  61             } else if (propName.equalsIgnoreCase(MacAddress.name)) {
  62                 return new MacAddress(propValue);
  63             } else {
  64                 log.debug("Not able to create {} property", propName);
  65             }
  66         } catch (Exception e) {
  67             log.debug("createProperty caught exception {}", e.getMessage());
  68         }
  69         return null;
  70     }
  71
  72     override doesNodeConnectorExist(NodeConnector nc) {
  73         val ref = nc.toNodeConnectorRef
  74         return dataService.readOperationalData(ref.value as InstanceIdentifier<? extends DataObject>) !== null
  75     }
  76
  77     override getControllerMAC() {
  78         var byte[] macAddress = null;
  79
  80         try {
  81             val nis = NetworkInterface.getNetworkInterfaces();
  82             while (nis.hasMoreElements()) {
  83                 val ni = nis.nextElement();
  84                 try {
  85                     macAddress = ni.getHardwareAddress();
  86                     return macAddress;
  87                 } catch (SocketException e) {
  88                     log.error("Failed to acquire controller MAC: ", e);
  89                 }
  90             }
  91         } catch (SocketException e) {
  92             log.error("Failed to acquire controller MAC: ", e);
  93             return macAddress;
  94         }
  95
  96         if (macAddress == null) {
  97             log.warn("Failed to acquire controller MAC: No physical interface found");
  98
  99             // This happens when running controller on windows VM, for example
 100             // Try parsing the OS command output
 101             }
 102             return macAddress;
 103         }
 104
 105     override getControllerProperties() {
 106         return Collections.emptyMap()
 107     }
 108
 109     override getControllerProperty(String propertyName) {
 110         return null;
 111     }
 112
 113     override getNetworkDevices() {
 114         val path = InstanceIdentifier.builder().node(Nodes).toInstance;
 115         val data = dataService.readOperationalData(path) as Nodes;
 116         val ret = new ArrayList<Switch>();
 117         for (node : data.node) {
 118             ret.add(node.toSwitch());
 119         }
 120         return ret;
 121     }
 122
 123     override getNodeConnector(Node node, String nodeConnectorName) {
 124         val key = new NodeConnectorKey(new NodeConnectorId(nodeConnectorName));
 125         return new NodeConnector(MD_SAL_TYPE, key, node);
 126     }
 127
 128     override getNodeConnectorProp(NodeConnector nodeConnector, String propName) {
 129         getNodeConnectorProps(nodeConnector).get(propName);
 130     }
 131
 132     override getNodeConnectorProps(NodeConnector nodeConnector) {
 133         val ref = nodeConnector.toNodeConnectorRef
 134         val data = readNodeConnector(ref.value);
 135         return data.toAdProperties();
 136     }
 137
 138     override getNodeConnectors(Node node) {
 139         val ref = node.toNodeRef;
 140         val data = readNode(ref.value);
 141         val ret = new HashSet();
 142         for (nc : data.nodeConnector) {
 143
 144             val adConnector = new NodeConnector(MD_SAL_TYPE, nc.key, node);
 145             ret.add(adConnector);
 146         }
 147         return ret;
 148     }
 149
 150     override getNodeDescription(Node node) {
 151         (getNodeProps(node).get(Description.propertyName) as Description).value;
 152     }
 153
 154     override getNodeMAC(Node node) {
 155         (getNodeProps(node).get(MacAddress.name) as MacAddress).macAddress;
 156     }
 157
 158     override getNodeProp(Node node, String propName) {
 159         getNodeProps(node).get(propName)
 160     }
 161
 162     override getNodeProps(Node node) {
 163         val ref = node.toNodeRef;
 164         val data = dataService.readOperationalData(ref.value as InstanceIdentifier<? extends DataObject>) as org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
 165         return data.toAdProperties();
 166     }
 167
 168     override getNodes() {
 169         val path = InstanceIdentifier.builder().node(Nodes).toInstance;
 170         val data = dataService.readOperationalData(path) as Nodes;
 171         val ret = new HashSet<Node>();
 172         for (node : data.node) {
 173             ret.add(new Node(MD_SAL_TYPE, node.key));
 174         }
 175         return ret;
 176     }
 177
 178     def Switch toSwitch(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node node) {
 179         val adNode = new Node(MD_SAL_TYPE, node.key);
 180         val sw = new Switch(adNode)
 181         return sw;
 182     }
 183
 184     override getPhysicalNodeConnectors(Node node) {
 185         val ref = node.toNodeRef;
 186         val data = readNode(ref.value);
 187         val ret = new HashSet();
 188         for (nc : data.nodeConnector) {
 189             val flowConnector = nc.getAugmentation(FlowCapableNodeConnector)
 190             val adConnector = new NodeConnector(MD_SAL_TYPE, nc.key, node);
 191             ret.add(adConnector);
 192         }
 193         return ret;
 194     }
 195
 196     def Map<String, Property> toAdProperties(
 197         org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector connector) {
 198         return Collections.emptyMap
 199     }
 200
 201     def Map<String, Property> toAdProperties(
 202         org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node connector) {
 203         return Collections.emptyMap
 204     }
 205
 206     def readNode(InstanceIdentifier<?> ref) {
 207         dataService.readOperationalData(ref as InstanceIdentifier<? extends DataObject>) as org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node
 208     }
 209
 210     def readNodeConnector(InstanceIdentifier<?> ref) {
 211         dataService.readOperationalData(ref as InstanceIdentifier<? extends DataObject>) as org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector
 212     }
 213
 214     override getSpanPorts(Node node) {
 215         throw new UnsupportedOperationException("TODO: auto-generated method stub")
 216     }
 217
 218     override getSubnetByNetworkAddress(InetAddress networkAddress) {
 219         throw new UnsupportedOperationException("TODO: auto-generated method stub")
 220     }
 221
 222     override getUpNodeConnectors(Node node) {
 223         val ref = node.toNodeRef
 224         val data = readNode(ref.value);
 225         val ret = new HashSet<NodeConnector>();
 226         for (nc : data.nodeConnector) {
 227             val flowConn = nc.getAugmentation(FlowCapableNodeConnector);
 228             if (flowConn != null && flowConn.state == PortState.Live) {
 229                 ret.add(new NodeConnector(MD_SAL_TYPE, nc.key, node));
 230             }
 231         }
 232         return ret;
 233     }
 234
 235     override isNodeConnectorEnabled(NodeConnector nodeConnector) {
 236         val ref = nodeConnector.toNodeConnectorRef
 237         val data = readNodeConnector(ref.value);
 238
 239         return true;
 240     }
 241
 242     override isSpecial(NodeConnector p) {
 243         val ref = p.toNodeConnectorRef
 244         val data = readNodeConnector(ref.value);
 245
 246         return true;
 247     }
 248
 249     override removeControllerProperty(String propertyName) {
 250         // NOOP
 251     }
 252
 253     override removeNodeAllProps(Node node) {
 254         // NOOP: not supported node has more properties than AD-SAL is capable to see
 255     }
 256
 257     override removeNodeConnectorAllProps(NodeConnector nodeConnector) {
 258         // NOOP: not supported node has more properties than AD-SAL is capable to see
 259     }
 260
 261     override removeNodeConnectorProp(NodeConnector nc, String propName) {
 262         // NOOP: not supported node has more properties than AD-SAL is capable to see
 263     }
 264
 265     override removeNodeProp(Node node, String propName) {
 266         // NOOP: not supported node has more properties than AD-SAL is capable to see
 267     }
 268
 269     override removePortsFromSubnet(String name, List<String> nodeConnectors) {
 270         // NOOP
 271     }
 272
 273     override removeSubnet(String name) {
 274         // NOOP
 275     }
 276
 277     override setControllerProperty(Property property) {
 278         // NOOP
 279     }
 280
 281     override setNodeProp(Node node, Property prop) {
 282         throw new UnsupportedOperationException("TODO: auto-generated method stub")
 283     }
 284
 285     override addPortsToSubnet(String name, List<String> nodeConnectors) {
 286         throw new UnsupportedOperationException("TODO: auto-generated method stub")
 287     }
 288
 289     }