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