20d375fc78eb3b7e26d425c9614c448eb3ec0d13
[controller.git] / 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 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.