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

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