2 * Copyright (c) 2016 CableLabs and others. All rights reserved.
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
8 package org.opendaylight.unimgr.impl;
10 import java.net.InetAddress;
11 import java.net.UnknownHostException;
12 import java.util.ArrayList;
13 import java.util.HashMap;
14 import java.util.HashSet;
15 import java.util.List;
17 import java.util.Map.Entry;
19 import java.util.UUID;
21 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
22 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
23 import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
24 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
25 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
26 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
27 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
28 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
29 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
30 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesBuilder;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesKey;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Queues;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QueuesBuilder;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QueuesKey;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosOtherConfig;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosOtherConfigBuilder;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosOtherConfigKey;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QueueList;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QueueListBuilder;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QueueListKey;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesOtherConfig;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesOtherConfigBuilder;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesOtherConfigKey;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsBuilder;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.OptionsKey;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.EvcAugmentation;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.EvcAugmentationBuilder;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.Uni;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.UniAugmentation;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.UniAugmentationBuilder;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniDest;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniDestBuilder;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniDestKey;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniSource;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniSourceBuilder;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniSourceKey;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.service.speed.Speed;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.service.speed.speed.Speed100M;
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.service.speed.speed.Speed10G;
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.service.speed.speed.Speed10M;
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.service.speed.speed.Speed1G;
88 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
89 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
90 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
91 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
92 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
93 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.LinkBuilder;
94 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
95 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
96 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
97 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
98 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
99 import org.opendaylight.yangtools.yang.binding.DataObject;
100 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
101 import org.slf4j.Logger;
102 import org.slf4j.LoggerFactory;
104 import com.google.common.base.Optional;
105 import com.google.common.collect.ImmutableBiMap;
106 import com.google.common.collect.Lists;
107 import com.google.common.util.concurrent.CheckedFuture;
109 public class UnimgrUtils {
111 private static final Logger LOG = LoggerFactory.getLogger(UnimgrUtils.class);
114 * Creates and submit a Bridge Node to the Configuration Data Store.
115 * @param dataBroker The Data Broker Instance to create a transaction
116 * @param ovsdbNode The OVSDB node
117 * @param uni The UNI linked to the OVSDB node
118 * @param bridgeName The bridge name (example: br0)
120 public static void createBridgeNode(DataBroker dataBroker,
124 LOG.info("Creating a bridge on node {}", ovsdbNode.getNodeId().getValue());
125 final InstanceIdentifier<Node> ovsdbNodeIid = uni.getOvsdbNodeRef().getValue().firstIdentifierOf(Node.class);
126 if (ovsdbNodeIid != null) {
127 final NodeBuilder bridgeNodeBuilder = new NodeBuilder();
128 final InstanceIdentifier<Node> bridgeIid = UnimgrMapper.createOvsdbBridgeNodeIid(ovsdbNode,
130 final NodeId bridgeNodeId = new NodeId(ovsdbNode.getNodeId()
131 + UnimgrConstants.DEFAULT_BRIDGE_NODE_ID_SUFFIX
133 bridgeNodeBuilder.setNodeId(bridgeNodeId);
134 final OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
135 ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
136 ovsdbBridgeAugmentationBuilder.setProtocolEntry(UnimgrUtils.createMdsalProtocols());
137 final OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
138 ovsdbBridgeAugmentationBuilder.setManagedBy(ovsdbNodeRef);
139 bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build());
140 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
141 transaction.put(LogicalDatastoreType.CONFIGURATION, bridgeIid, bridgeNodeBuilder.build());
142 transaction.submit();
144 LOG.info("OvsdbNodeRef is null");
149 * Creates and submit a Bridge Node to the Configuration Data Store.
150 * @param dataBroker The Data Broker Instance to create a transaction
151 * @param ovsdbNodeIid The OVSDB node Instance Identifier
152 * @param uni The UNI linked to the OVSDB node
153 * @param bridgeName The bridge name (example: br0)
155 public static void createBridgeNode(DataBroker dataBroker,
156 InstanceIdentifier<Node> ovsdbNodeIid,
159 LOG.info("Creating a bridge on node {}", ovsdbNodeIid);
160 if (ovsdbNodeIid != null) {
161 final NodeBuilder bridgeNodeBuilder = new NodeBuilder();
162 final Optional<Node> optionalOvsdbNode = UnimgrUtils.readNode(dataBroker,
163 LogicalDatastoreType.OPERATIONAL,
165 if (optionalOvsdbNode.isPresent()) {
166 final Node ovsdbNode = optionalOvsdbNode.get();
167 final InstanceIdentifier<Node> bridgeIid = UnimgrMapper.createOvsdbBridgeNodeIid(ovsdbNode,
169 final NodeId bridgeNodeId = new NodeId(ovsdbNode.getNodeId().getValue()
170 + UnimgrConstants.DEFAULT_BRIDGE_NODE_ID_SUFFIX
172 bridgeNodeBuilder.setNodeId(bridgeNodeId);
173 final OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
174 ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridgeName));
175 ovsdbBridgeAugmentationBuilder.setProtocolEntry(UnimgrUtils.createMdsalProtocols());
176 final OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
177 ovsdbBridgeAugmentationBuilder.setManagedBy(ovsdbNodeRef);
178 bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class,
179 ovsdbBridgeAugmentationBuilder.build());
180 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
181 transaction.put(LogicalDatastoreType.CONFIGURATION,
183 bridgeNodeBuilder.build());
184 transaction.submit();
187 LOG.info("OvsdbNodeRef is null");
192 * Creates a List of Controller Entry to be used when adding controllers
194 * @param targetString The URI in string format of the Controller Entry
195 * @return A List of Controller Entry to be used when adding controllers
197 public static List<ControllerEntry> createControllerEntries(String targetString) {
198 final List<ControllerEntry> controllerEntries = new ArrayList<ControllerEntry>();
199 final ControllerEntryBuilder controllerEntryBuilder = new ControllerEntryBuilder();
200 controllerEntryBuilder.setTarget(new Uri(targetString));
201 controllerEntries.add(controllerEntryBuilder.build());
202 return controllerEntries;
206 * Creates a submit a GRE tunnel to the Configuration DataStore.
207 * @param dataBroker An instance of the Data Broker to create a transaction
208 * @param source The source UNI
209 * @param destination The destination UNI
210 * @param bridgeNode The bridge Node
211 * @param bridgeName The bridge name (example br0)
212 * @param portName The Port Name (example: eth0)
214 public static void createGreTunnel(DataBroker dataBroker,
220 final InstanceIdentifier<TerminationPoint> tpIid =
221 UnimgrMapper.getTerminationPointIid(bridgeNode,
223 final OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
224 new OvsdbTerminationPointAugmentationBuilder();
225 tpAugmentationBuilder.setName(portName);
226 final ArrayList<Options> options = Lists.newArrayList();
227 final OptionsKey optionKey = new OptionsKey("remote_ip");
228 final Options destinationIp = new OptionsBuilder()
229 .setOption(destination.getIpAddress().getIpv4Address().getValue())
230 .setKey(optionKey).setValue(destination.getIpAddress().getIpv4Address().getValue())
232 options.add(destinationIp);
233 tpAugmentationBuilder.setOptions(options);
234 tpAugmentationBuilder.setInterfaceType(SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.get("gre"));
235 if (source.getSpeed() != null) {
236 final Uuid qosUuid = getQosUuid(dataBroker, source);
237 tpAugmentationBuilder.setQos(getQosUuid(dataBroker, source));
238 LOG.info("Updating Qos {} to termination point {}", qosUuid , bridgeName);
240 final TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
241 tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
242 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
243 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
244 transaction.put(LogicalDatastoreType.CONFIGURATION,
247 transaction.submit();
251 * Utility function used to create a protocol entry when creating a bridge node.
252 * @return A List of protocol entry
254 public static List<ProtocolEntry> createMdsalProtocols() {
255 final List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
256 final ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
257 SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
258 protocolList.add(new ProtocolEntryBuilder().
259 setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build());
264 * Creates a Bridge Augmentation by using a UNI
265 * @param uni Contains data used to create the augmentation
266 * @return A Built OvsdbBridgeAugmentation with data.
267 * @throws Exception if the Ovsdb Node Reference cannot be found.
269 public static OvsdbBridgeAugmentation createOvsdbBridgeAugmentation(Uni uni) throws Exception {
270 final OvsdbNodeRef ovsdbNodeRef = uni.getOvsdbNodeRef();
271 if (ovsdbNodeRef != null && ovsdbNodeRef.getValue() != null) {
272 final UUID bridgeUuid = UUID.randomUUID();
273 final OvsdbBridgeAugmentation ovsdbBridge = new OvsdbBridgeAugmentationBuilder()
275 new OvsdbBridgeName(UnimgrConstants.DEFAULT_BRIDGE_NAME))
276 .setManagedBy(ovsdbNodeRef)
278 new Uuid(bridgeUuid.toString()))
282 throw new Exception("Ovsdb Node Reference does not exist !");
287 * Creates a submit an OvsdbNode to the Configuration DataStore.
288 * @param dataBroker The instance of the Data Broker to create transactions.
289 * @param ovsdbNodeId The Ovsdb Node Id to use on creation
290 * @param uni The UNI's data
292 public static void createOvsdbNode(DataBroker dataBroker,
295 final InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper.getOvsdbNodeIid(uni.getIpAddress());
297 final NodeKey ovsdbNodeKey = new NodeKey(ovsdbNodeId);
298 final Node nodeData = new NodeBuilder()
299 .setNodeId(ovsdbNodeId)
300 .setKey(ovsdbNodeKey)
301 .addAugmentation(OvsdbNodeAugmentation.class,
302 UnimgrUtils.createOvsdbNodeAugmentation(uni))
304 // Submit the node to the datastore
305 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
306 transaction.put(LogicalDatastoreType.CONFIGURATION, ovsdbNodeIid, nodeData);
307 transaction.submit();
308 LOG.info("Created and submitted a new OVSDB node {}", nodeData.getNodeId());
309 } catch (final Exception e) {
310 LOG.error("Exception while creating OvsdbNodeAugmentation, " + "Uni is null. Node Id: {}", ovsdbNodeId);
315 * Creates and submit an OvsdbNode by using the Data contained in the UniAugmentation
316 * @param dataBroker The instance of the DataBroker to create transactions
317 * @param uni The UNI's data
318 * @return The instance of the Node
320 public static Node createOvsdbNode(DataBroker dataBroker,
321 UniAugmentation uni) {
322 final NodeId ovsdbNodeId = new NodeId(createOvsdbNodeId(uni.getIpAddress()));
324 final InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper.getOvsdbNodeIid(ovsdbNodeId);
325 final NodeKey ovsdbNodeKey = new NodeKey(ovsdbNodeId);
326 final Node nodeData = new NodeBuilder()
327 .setNodeId(ovsdbNodeId)
328 .setKey(ovsdbNodeKey)
329 .addAugmentation(OvsdbNodeAugmentation.class,
330 UnimgrUtils.createOvsdbNodeAugmentation(uni))
332 // Submit the node to the datastore
333 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
334 transaction.put(LogicalDatastoreType.CONFIGURATION, ovsdbNodeIid, nodeData);
335 transaction.submit();
336 LOG.info("Created and submitted a new OVSDB node {}", nodeData.getNodeId());
338 } catch (final Exception e) {
339 LOG.error("Exception while creating OvsdbNodeAugmentation, " + "Uni is null. Node Id: {}", ovsdbNodeId);
345 * Creates and Build the data for an OvsdbNodeAugmentation.
346 * @param uni The UNI"s data
347 * @return The built OsvdbNodeAugmentation
349 public static OvsdbNodeAugmentation createOvsdbNodeAugmentation(Uni uni) {
350 final ConnectionInfo connectionInfos = new ConnectionInfoBuilder()
351 .setRemoteIp(uni.getIpAddress())
352 .setRemotePort(new PortNumber(UnimgrConstants.OVSDB_PORT))
354 final OvsdbNodeAugmentation ovsdbNode = new OvsdbNodeAugmentationBuilder()
355 .setConnectionInfo(connectionInfos).build();
359 public static OvsdbNodeAugmentation createOvsdbNodeAugmentation(UniAugmentation uni,
360 PortNumber remotePort) {
361 final ConnectionInfo connectionInfos = new ConnectionInfoBuilder()
362 .setRemoteIp(uni.getIpAddress())
363 .setRemotePort(remotePort)
365 final OvsdbNodeAugmentation ovsdbNode = new OvsdbNodeAugmentationBuilder()
366 .setConnectionInfo(connectionInfos)
367 .setQosEntries(createQosEntries(uni))
368 .setQueues(createQueues(uni))
373 public static Node createQoSForOvsdbNode (DataBroker dataBroker, UniAugmentation uni) {
374 final Optional<Node> optionalNode = findOvsdbNode(dataBroker, uni);
375 if (optionalNode.isPresent()) {
376 final NodeId ovsdbNodeId = optionalNode.get().getNodeId();
377 final InstanceIdentifier<OvsdbNodeAugmentation> ovsdbNodeAugmentationIid = UnimgrMapper
378 .getOvsdbNodeIid(ovsdbNodeId)
379 .augmentation(OvsdbNodeAugmentation.class);
380 final OvsdbNodeAugmentation ovsdbNodeAugmentation = createOvsdbNodeAugmentation(uni,
381 getRemotePort(dataBroker, uni));
382 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
383 transaction.put(LogicalDatastoreType.CONFIGURATION, ovsdbNodeAugmentationIid, ovsdbNodeAugmentation, true);
384 final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
386 Thread.sleep(UnimgrConstants.OVSDB_UPDATE_TIMEOUT);
387 } catch (final InterruptedException e) {
388 LOG.warn("Interrupted while waiting after OVSDB node augmentation {} {}", ovsdbNodeId, e);
392 LOG.trace("Update qos and queues to ovsdb for node {} {}", ovsdbNodeId, ovsdbNodeAugmentationIid);
393 } catch (final TransactionCommitFailedException e) {
394 LOG.warn("Failed to put {} ", ovsdbNodeAugmentationIid, e);
396 updateQosEntries(dataBroker, uni);
401 private static PortNumber getRemotePort(DataBroker dataBroker, UniAugmentation uni) {
402 PortNumber remotePort = null;
403 final Optional<Node> optionalNode = findOvsdbNode(dataBroker, uni);
405 if (optionalNode.isPresent()) {
406 remotePort = optionalNode.get()
407 .getAugmentation(OvsdbNodeAugmentation.class)
408 .getConnectionInfo().getRemotePort();
413 private static List<QosEntries> createQosEntries(Uni uni) {
414 // Configure queue for best-effort dscp and max rate
415 final List<QosOtherConfig> otherConfig = new ArrayList<>();
416 QosOtherConfig qOtherConfig = new QosOtherConfigBuilder()
417 .setKey(new QosOtherConfigKey(UnimgrConstants.QOS_DSCP_ATTRIBUTE))
418 .setOtherConfigKey(UnimgrConstants.QOS_DSCP_ATTRIBUTE)
419 .setOtherConfigValue(UnimgrConstants.QOS_DSCP_ATTRIBUTE_VALUE)
421 otherConfig.add(qOtherConfig);
423 qOtherConfig = new QosOtherConfigBuilder()
424 .setKey(new QosOtherConfigKey(UnimgrConstants.QOS_MAX_RATE))
425 .setOtherConfigKey(UnimgrConstants.QOS_MAX_RATE)
426 .setOtherConfigValue(getSpeed(uni.getSpeed().getSpeed()))
428 otherConfig.add(qOtherConfig);
430 final Uuid qosUuid = new Uuid(UUID.randomUUID().toString());
431 final QosEntries qosEntry = new QosEntriesBuilder()
432 .setKey(new QosEntriesKey(new Uri(UnimgrConstants.QOS_PREFIX + qosUuid.getValue())))
433 .setQosId(new Uri(UnimgrConstants.QOS_PREFIX + qosUuid.getValue()))
434 .setQosOtherConfig(otherConfig)
435 .setQosType(SouthboundMapper.createQosType(SouthboundConstants.QOS_LINUX_HTB))
438 final List<QosEntries> qosEntries = new ArrayList<>();
439 qosEntries.add(qosEntry);
443 private static List<Queues> createQueues(Uni uni) {
444 final List<QueuesOtherConfig> otherConfig = new ArrayList<>();
445 QueuesOtherConfig queuesOtherConfig = new QueuesOtherConfigBuilder()
446 .setKey(new QueuesOtherConfigKey(UnimgrConstants.QOS_DSCP_ATTRIBUTE))
447 .setQueueOtherConfigKey(UnimgrConstants.QOS_DSCP_ATTRIBUTE)
448 .setQueueOtherConfigValue(UnimgrConstants.QOS_DSCP_ATTRIBUTE_VALUE)
450 otherConfig.add(queuesOtherConfig);
452 queuesOtherConfig = new QueuesOtherConfigBuilder()
453 .setKey(new QueuesOtherConfigKey(UnimgrConstants.QOS_MAX_RATE))
454 .setQueueOtherConfigKey(UnimgrConstants.QOS_MAX_RATE)
455 .setQueueOtherConfigValue(getSpeed(uni.getSpeed().getSpeed()))
457 otherConfig.add(queuesOtherConfig);
459 // Configure dscp value for best-effort
460 final Uuid queueUuid = new Uuid(UUID.randomUUID().toString());
461 final Queues queues = new QueuesBuilder()
462 .setDscp(Short.parseShort(UnimgrConstants.QOS_DSCP_ATTRIBUTE_VALUE))
463 .setKey(new QueuesKey(new Uri(UnimgrConstants.QUEUE_PREFIX + queueUuid.getValue())))
464 .setQueueId(new Uri(UnimgrConstants.QUEUE_PREFIX + queueUuid.getValue()))
465 .setQueuesOtherConfig(otherConfig)
468 final List<Queues> queuesList = new ArrayList<>();
469 queuesList.add(queues);
473 private static String getSpeed(Speed speedObject) {
475 if (speedObject instanceof Speed10M) {
479 else if (speedObject instanceof Speed100M) {
483 else if (speedObject instanceof Speed1G) {
487 else if (speedObject instanceof Speed10G) {
494 private static void updateQosEntries(DataBroker dataBroker, UniAugmentation uni) {
495 final Optional<Node> optionalNode = findOvsdbNode(dataBroker, uni);
496 if (optionalNode.isPresent()) {
497 final NodeId ovsdbNodeId = optionalNode.get().getNodeId();
498 final Long queueNumber = 0L;
499 final List<QosEntries> qosList = optionalNode.get()
500 .getAugmentation(OvsdbNodeAugmentation.class)
502 LOG.trace("QOS entries list {} for node {}", qosList, ovsdbNodeId);
503 QosEntriesKey qosEntryKey = null;
504 for (final QosEntries qosEntry : qosList) {
505 qosEntryKey = qosEntry.getKey();
507 final InstanceIdentifier<QueueList> queueIid = UnimgrMapper
508 .getOvsdbQueueListIid(ovsdbNodeId, qosEntryKey, queueNumber);
510 Uuid queueUuid = null;
511 final List<Queues> queuesList = optionalNode.get()
512 .getAugmentation(OvsdbNodeAugmentation.class).getQueues();
513 for (final Queues queue : queuesList) {
514 queueUuid = queue.getQueueUuid();
516 final QueueList queueList = new QueueListBuilder()
517 .setKey(new QueueListKey(queueNumber))
518 .setQueueNumber(queueNumber)
519 .setQueueUuid(queueUuid)
522 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
523 transaction.put(LogicalDatastoreType.CONFIGURATION, queueIid, queueList, true);
524 final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
527 LOG.info("Update qos-entries to ovsdb for node {} {}", ovsdbNodeId, queueIid);
528 } catch (final TransactionCommitFailedException e) {
529 LOG.warn("Failed to put {} ", queueIid, e);
534 public static void updateMaxRate (DataBroker dataBroker,
535 UniAugmentation sourceUniAugmentation,
536 UniAugmentation destinationUniAugmentation,
537 EvcAugmentation evc) {
538 Optional<Node> optionalNode;
539 if (getSpeed(sourceUniAugmentation.getSpeed().getSpeed()).equals(getSpeed(evc.getIngressBw().getSpeed()))) {
540 LOG.info("Source UNI speed matches EVC ingress BW");
542 // update Uni's ovsdbNodeRef qos-entries and queues for max-rate to match EVC ingress BW
543 optionalNode = findOvsdbNode(dataBroker, sourceUniAugmentation);
544 if (optionalNode.isPresent()) {
545 updateQosMaxRate(dataBroker, optionalNode, evc);
546 updateQueuesMaxRate(dataBroker, optionalNode, evc);
550 if (getSpeed(destinationUniAugmentation.getSpeed().getSpeed()).equals(getSpeed(evc.getIngressBw().getSpeed()))) {
551 LOG.info("Destination UNI speed matches EVC ingress BW");
553 // update Uni's ovsdbNodeRef qos-entries and queues for max-rate to match EVC ingress BW
554 optionalNode = findOvsdbNode(dataBroker, destinationUniAugmentation);
555 if (optionalNode.isPresent()) {
556 updateQosMaxRate(dataBroker, optionalNode, evc);
557 updateQueuesMaxRate(dataBroker, optionalNode, evc);
562 private static void updateQosMaxRate(DataBroker dataBroker,
563 Optional<Node> optionalOvsdbNode,
564 EvcAugmentation evc) {
565 final NodeId ovsdbNodeId = optionalOvsdbNode.get().getNodeId();
566 final List<QosEntries> qosList = optionalOvsdbNode.get()
567 .getAugmentation(OvsdbNodeAugmentation.class)
569 LOG.trace("QOS entries list {} for node {}", qosList, ovsdbNodeId);
570 QosEntriesKey qosEntryKey = null;
571 for (final QosEntries qosEntry : qosList) {
572 qosEntryKey = qosEntry.getKey();
574 final InstanceIdentifier<QosOtherConfig> qosOtherConfigIid = UnimgrMapper
575 .getQosOtherConfigIid(ovsdbNodeId, qosEntryKey);
576 final QosOtherConfig qOtherConfig = new QosOtherConfigBuilder()
577 .setKey(new QosOtherConfigKey(UnimgrConstants.QOS_MAX_RATE))
578 .setOtherConfigKey(UnimgrConstants.QOS_MAX_RATE)
579 .setOtherConfigValue(getSpeed(evc.getIngressBw().getSpeed()))
581 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
582 transaction.put(LogicalDatastoreType.CONFIGURATION, qosOtherConfigIid, qOtherConfig, true);
583 final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
586 LOG.info("Update qos-entries max-rate to ovsdb for node {} {}", ovsdbNodeId, qosOtherConfigIid);;
587 } catch (final TransactionCommitFailedException e) {
588 LOG.warn("Failed to put {} ", qosOtherConfigIid, e);
592 private static void updateQueuesMaxRate(DataBroker dataBroker,
593 Optional<Node> optionalOvsdbNode,
594 EvcAugmentation evc) {
595 final NodeId ovsdbNodeId = optionalOvsdbNode.get().getNodeId();
596 final List<Queues> queues = optionalOvsdbNode.get()
597 .getAugmentation(OvsdbNodeAugmentation.class)
599 QueuesKey queuesKey = null;
600 for (final Queues queue: queues) {
601 queuesKey = queue.getKey();
603 final InstanceIdentifier<QueuesOtherConfig> queuesOtherConfigIid = UnimgrMapper
604 .getQueuesOtherConfigIid(ovsdbNodeId, queuesKey);
605 final QueuesOtherConfig queuesOtherConfig = new QueuesOtherConfigBuilder()
606 .setKey(new QueuesOtherConfigKey(UnimgrConstants.QOS_MAX_RATE))
607 .setQueueOtherConfigKey(UnimgrConstants.QOS_MAX_RATE)
608 .setQueueOtherConfigValue(getSpeed(evc.getIngressBw().getSpeed()))
610 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
611 transaction.put(LogicalDatastoreType.CONFIGURATION, queuesOtherConfigIid, queuesOtherConfig, true);
612 final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
615 LOG.info("Update queues max-rate to ovsdb for node {} {}", ovsdbNodeId, queuesOtherConfigIid);;
616 } catch (final TransactionCommitFailedException e) {
617 LOG.warn("Failed to put {} ", queuesOtherConfigIid, e);
622 * Creates an OVSDB node Id with an IP Address.
623 * @param ipAddress The IP address of the UNI (therefo the OVSDB node)
624 * @return A NodeId for a Specific Ovsdb Node Id
626 public static NodeId createOvsdbNodeId(IpAddress ipAddress) {
627 final String nodeId = UnimgrConstants.OVSDB_PREFIX
628 + ipAddress.getIpv4Address().getValue().toString()
630 + UnimgrConstants.OVSDB_PORT;
631 return new NodeId(nodeId);
635 * Creates a built OvsdbTerminationAugmentation with data
636 * @param uni The UNI's data
637 * @return A Built OvsdbTerminationPointAugmentation with data
639 public static OvsdbTerminationPointAugmentation createOvsdbTerminationPointAugmentation(Uni uni) {
640 // we will use nodeId to set interface port id
641 final VlanId vlanID = new VlanId(1);
642 final OvsdbTerminationPointAugmentation terminationPoint = new OvsdbTerminationPointAugmentationBuilder()
643 .setName(UnimgrConstants.DEFAULT_INTERNAL_IFACE)
645 .setVlanMode(VlanMode.Access)
647 return terminationPoint;
651 * Creates and submit an evc by using the Data contained in the EvcAugmentation
652 * @param dataBroker The instance of the DataBroker to create transactions
653 * @param evc The EVC's data
654 * @return true if evc created
656 public static boolean createEvc(DataBroker dataBroker, EvcAugmentation evc) {
661 * Creates and submit an UNI Node by using the Data contained in the UniAugmentation
662 * @param dataBroker The instance of the DataBroker to create transactions
663 * @param uni The UNI's data
664 * @return true if uni created
666 public static boolean createUniNode(DataBroker dataBroker, UniAugmentation uni) {
667 final NodeId uniNodeId = new NodeId(createUniNodeId(uni.getIpAddress()));
668 boolean result = false;
670 final InstanceIdentifier<Node> uniNodeIid = UnimgrMapper.getUniNodeIid(uniNodeId);
671 final NodeKey uniNodeKey = new NodeKey(uniNodeId);
672 final Node nodeData = new NodeBuilder()
673 .setNodeId(uniNodeId)
675 .addAugmentation(UniAugmentation.class, uni)
677 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
678 transaction.put(LogicalDatastoreType.CONFIGURATION, uniNodeIid, nodeData);
679 final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
682 LOG.info("Created and submitted a new Uni node {}", nodeData.getNodeId());
683 } catch (final Exception e) {
684 LOG.error("Exception while creating Uni Node" + "Uni Node Id: {}", uniNodeId);
690 * Creates an UNI node Id with an IP Address.
691 * @param ipAddress The IP address of the UNI
692 * @return A NodeId for a Specific UNI Node Id
694 public static NodeId createUniNodeId(IpAddress ipAddress) {
695 return new NodeId(UnimgrConstants.UNI_PREFIX + ipAddress.getIpv4Address().getValue().toString());
699 * Creates and Submit a termination point Node to the configuration DateStore.
700 * @param dataBroker The instance of the data broker to create transactions
701 * @param uni The UNI's data
702 * @param bridgeNode The Bridge node
703 * @param bridgeName The Bridge name (example: br0)
704 * @param portName The Port name (example: eth0)
705 * @param type The type of termination (example: gre) Refer to OVSDB_INTERFACE_TYPE_MAP
706 * to review the list of available Interface Types.
708 public static void createTerminationPointNode(DataBroker dataBroker,
714 final InstanceIdentifier<TerminationPoint> tpIid = UnimgrMapper
715 .getTerminationPointIid(bridgeNode,
717 final OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
718 new OvsdbTerminationPointAugmentationBuilder();
719 tpAugmentationBuilder.setName(portName);
721 tpAugmentationBuilder.setInterfaceType(SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.get(type));
723 final TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
724 tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
725 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class,
726 tpAugmentationBuilder.build());
727 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
728 transaction.put(LogicalDatastoreType.CONFIGURATION,
731 transaction.submit();
735 * Creates and Submit a termination point Node without specifying its interface type.
736 * @param dataBroker The instance of the data broker to create transactions
737 * @param uni The UNI's data
738 * @param bridgeNode The Bridge node
739 * @param bridgeName The Bridge name (example: br0)
740 * @param portName The Port name (example: eth0)
742 public static void createTerminationPointNode(DataBroker dataBroker,
747 final InstanceIdentifier<TerminationPoint> tpIid = UnimgrMapper
748 .getTerminationPointIid(bridgeNode,
750 final OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
751 new OvsdbTerminationPointAugmentationBuilder();
752 tpAugmentationBuilder.setName(portName);
753 tpAugmentationBuilder.setInterfaceType(null);
754 if (uni.getSpeed() != null) {
755 final Uuid qosUuid = getQosUuid(dataBroker, uni);
756 tpAugmentationBuilder.setQos(getQosUuid(dataBroker, uni));
757 LOG.info("Updating Qos {} to termination point {}", qosUuid , bridgeName);
759 final TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
760 tpBuilder.setKey(InstanceIdentifier.keyOf(tpIid));
761 tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class,
762 tpAugmentationBuilder.build());
763 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
764 transaction.put(LogicalDatastoreType.CONFIGURATION,
767 transaction.submit();
770 private static Uuid getQosUuid(DataBroker dataBroker, Uni uni) {
772 final Optional<Node> optionalNode = findUniNode(dataBroker, uni.getIpAddress());
774 if (optionalNode.isPresent()) {
775 final UniAugmentation uniAugmentation = optionalNode.get()
776 .getAugmentation(UniAugmentation.class);
777 final Optional<Node> ovsdbNode = findOvsdbNode(dataBroker, uniAugmentation);
778 if (ovsdbNode.isPresent()) {
779 final List<QosEntries> qosEntries = ovsdbNode.get()
780 .getAugmentation(OvsdbNodeAugmentation.class)
782 for (final QosEntries qosEntry : qosEntries) {
783 qosUuid = qosEntry.getQosUuid();
791 * Deletes a generic node
792 * @param dataBroker The instance of the data broker to create transactions
793 * @param store The DataStore where the delete
794 * @param path The path to delete
795 * @return An instance of a generic Data Object
797 public <D extends org.opendaylight.yangtools.yang.binding.DataObject> boolean delete(
798 DataBroker dataBroker,
799 final LogicalDatastoreType store,
800 final InstanceIdentifier<D> path) {
801 boolean result = false;
802 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
803 transaction.delete(store, path);
804 final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
808 } catch (final TransactionCommitFailedException e) {
809 LOG.warn("Failed to delete {} ", path, e);
814 public static void deleteEvcData(DataBroker dataBroker, Optional<Node> optionalUni) {
815 if (optionalUni.isPresent()) {
816 final UniAugmentation uniAugmentation =
819 .getAugmentation(UniAugmentation.class);
820 final InstanceIdentifier<Node> ovsdbNodeIid =
824 .firstIdentifierOf(Node.class);
825 final Optional<Node> optionalOvsdNode =
826 UnimgrUtils.readNode(dataBroker,
827 LogicalDatastoreType.OPERATIONAL,
829 if (optionalOvsdNode.isPresent()) {
830 final Node ovsdbNode = optionalOvsdNode.get();
831 final OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class);
832 for (final ManagedNodeEntry managedNodeEntry: ovsdbNodeAugmentation.getManagedNodeEntry()) {
833 final InstanceIdentifier<Node> bridgeIid = managedNodeEntry
836 .firstIdentifierOf(Node.class);
837 final Optional<Node> optBridgeNode = UnimgrUtils.readNode(dataBroker, bridgeIid);
838 if (optBridgeNode.isPresent()) {
839 final Node bridgeNode = optBridgeNode.get();
840 final InstanceIdentifier<TerminationPoint> iidGreTermPoint = UnimgrMapper.getTerminationPointIid(bridgeNode,
841 UnimgrConstants.DEFAULT_GRE_TUNNEL_NAME);
842 final InstanceIdentifier<TerminationPoint> iidEthTermPoint = UnimgrMapper.getTerminationPointIid(bridgeNode,
843 UnimgrConstants.DEFAULT_TUNNEL_IFACE);
844 UnimgrUtils.deleteNode(dataBroker, iidGreTermPoint, LogicalDatastoreType.CONFIGURATION);
845 UnimgrUtils.deleteNode(dataBroker, iidEthTermPoint, LogicalDatastoreType.CONFIGURATION);
850 LOG.info("Unable to retrieve UNI from the EVC.");
855 * Deletes a termination Point from the configuration data store.
856 * @param dataBroker The instance of the data broker to create transactions
857 * @param terminationPoint The Termination Point of the OVSDB bridge
858 * @param ovsdbNode The ovsdb Node
859 * @return A checked Future
861 public static CheckedFuture<Void,
862 TransactionCommitFailedException>
863 deleteTerminationPoint(DataBroker dataBroker,
864 TerminationPoint terminationPoint,
866 final InstanceIdentifier<TerminationPoint> terminationPointPath =
868 .create(NetworkTopology.class)
869 .child(Topology.class,
870 new TopologyKey(UnimgrConstants.OVSDB_TOPOLOGY_ID))
873 .child(TerminationPoint.class,
874 terminationPoint.getKey());
875 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
876 transaction.delete(LogicalDatastoreType.CONFIGURATION, terminationPointPath);
877 transaction.delete(LogicalDatastoreType.OPERATIONAL, terminationPointPath);
878 transaction.submit();
879 final CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
884 * Generic function to delete a node on a specific dataStore
885 * @param dataBroker The instance of the data broker to create transactions.
886 * @param genericNode The instance identifier of a generic node
887 * @param store The dataStore where to send and submit the delete call.
889 public static boolean deleteNode(DataBroker dataBroker,
890 InstanceIdentifier<?> genericNode,
891 LogicalDatastoreType store) {
892 LOG.info("Received a request to delete node {}", genericNode);
893 boolean result = false;
894 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
895 transaction.delete(store, genericNode);
897 transaction.submit().checkedGet();
899 } catch (final TransactionCommitFailedException e) {
900 LOG.error("Unable to remove node with Iid {} from store {}.", genericNode, store);
906 * Extract a data object by using its instance indentifier and it's class type.
907 * @param changes Data Change object
908 * @param klazz Class type
909 * @return The extracted DataObject as an Object casted as the class type
911 public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extract(
912 Map<InstanceIdentifier<?>, DataObject> changes, Class<T> klazz) {
913 final Map<InstanceIdentifier<T>,T> result = new HashMap<InstanceIdentifier<T>,T>();
914 if (changes != null && changes.entrySet() != null) {
915 for (final Entry<InstanceIdentifier<?>, DataObject> created : changes.entrySet()) {
916 if (klazz.isInstance(created.getValue())) {
917 @SuppressWarnings("unchecked")
919 T value = (T) created.getValue();
920 final Class<?> type = created.getKey().getTargetType();
921 if (type.equals(klazz)) {
922 @SuppressWarnings("unchecked") // Actually checked above
924 InstanceIdentifier<T> iid = (InstanceIdentifier<T>) created.getKey();
925 result.put(iid, value);
934 * Extract original data from the data store.
935 * @param changes The dataChange object
936 * @param klazz The class type
937 * @return The DataObject casted as a Class type
939 public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractOriginal(
940 AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
941 return extract(changes.getOriginalData(),klazz);
945 * Extracts the removed nodes
946 * @param changes he dataChange object
947 * @param klazz The class type
948 * @return A set to removed nodes as DataObject casted as the class type
950 public static <T extends DataObject> Set<InstanceIdentifier<T>> extractRemoved(
951 AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
952 final Set<InstanceIdentifier<T>> result = new HashSet<InstanceIdentifier<T>>();
953 if (changes != null && changes.getRemovedPaths() != null) {
954 for (final InstanceIdentifier<?> iid : changes.getRemovedPaths()) {
955 if (iid.getTargetType().equals(klazz)) {
956 @SuppressWarnings("unchecked") // Actually checked above
958 InstanceIdentifier<T> iidn = (InstanceIdentifier<T>)iid;
967 * Search the Operational Datastore for a specific OvsdbNode.
968 * @param dataBroker The dataBroker instance to create transactions
969 * @param uni The UNI's data
970 * @return The Optional OvsdbNode
972 public static Optional<Node> findOvsdbNode(DataBroker dataBroker,
973 UniAugmentation uni) {
974 final List<Node> ovsdbNodes = getOvsdbNodes(dataBroker);
975 Optional<Node> optionalOvsdb;
976 if (!ovsdbNodes.isEmpty()) {
977 for (final Node ovsdbNode : ovsdbNodes) {
978 final OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode
979 .getAugmentation(OvsdbNodeAugmentation.class);
980 if (ovsdbNodeAugmentation.getConnectionInfo()
983 .equals(uni.getIpAddress().getIpv4Address())) {
984 LOG.info("Found ovsdb node");
985 optionalOvsdb = Optional.of(ovsdbNode);
986 return optionalOvsdb;
990 return Optional.absent();
994 * Search the Operation DataStore for a specific UNI
995 * @param dataBroker The dataBroker instance to create transactions
996 * @param ipAddress The IP address of the UNI
997 * @return An Optional UNI Node
999 public static Optional<Node> findUniNode(DataBroker dataBroker,
1000 IpAddress ipAddress) {
1001 final List<Node> uniNodes = getUniNodes(dataBroker);
1002 if (!uniNodes.isEmpty()) {
1003 for (final Node uniNode : uniNodes) {
1004 final UniAugmentation uniAugmentation = uniNode.getAugmentation(UniAugmentation.class);
1005 if (uniAugmentation.getIpAddress().equals(ipAddress)) {
1006 LOG.info("Found Uni node");
1007 return Optional.of(uniNode);
1011 return Optional.absent();
1015 * Retrieves the connection information from an Ovsdb Connection by
1016 * using the Ovsdb Node Id
1017 * @param dataBroker The dataBroker instance to create transactions
1018 * @param ovsdbNodeId The NodeId of the OVSDB node
1019 * @return The ConnectionInfo object
1021 public static ConnectionInfo getConnectionInfo(DataBroker dataBroker,
1022 NodeId ovsdbNodeId) {
1023 final InstanceIdentifier<Node> nodeIid = UnimgrMapper.getOvsdbNodeIid(ovsdbNodeId);
1024 final Optional<Node> node = readNode(dataBroker,
1025 LogicalDatastoreType.OPERATIONAL,
1027 if (node.isPresent()) {
1028 final Node ovsdbNode = node.get();
1029 final OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode
1030 .getAugmentation(OvsdbNodeAugmentation.class);
1031 final ConnectionInfo connectionInfo = ovsdbNodeAugmentation.getConnectionInfo();
1032 return connectionInfo;
1039 * Retrieve the list of links in the Operational DataStore
1040 * @param dataBroker The dataBroker instance to create transactions
1041 * @return A list of Links retrieved from the Operational DataStore
1043 public static List<Link> getEvcLinks(DataBroker dataBroker) {
1044 final List<Link> evcLinks = new ArrayList<>();
1045 final InstanceIdentifier<Topology> evcTopology = UnimgrMapper.getEvcTopologyIid();
1046 final Topology topology = UnimgrUtils.read(dataBroker,
1047 LogicalDatastoreType.OPERATIONAL,
1049 if (topology != null && topology.getLink() != null) {
1050 for (final Link link : topology.getLink()) {
1051 final EvcAugmentation evcAugmentation = link.getAugmentation(EvcAugmentation.class);
1052 if (evcAugmentation != null) {
1061 * Retrieve the Local IP of the controller
1062 * @return The LocalIp object of the Controller
1064 public static IpAddress getLocalIp() {
1067 ip = InetAddress.getLocalHost().getHostAddress();
1068 final Ipv4Address ipv4 = new Ipv4Address(ip);
1069 final IpAddress ipAddress = new IpAddress(ipv4);
1071 } catch (final UnknownHostException e) {
1072 LOG.info("Unable to retrieve controller's ip address, using loopback.");
1074 return new IpAddress(UnimgrConstants.LOCAL_IP);
1078 * Retrieve a list of Ovsdb Nodes from the Operational DataStore
1079 * @param dataBroker The dataBroker instance to create transactions
1080 * @return The Ovsdb Node retrieved from the Operational DataStore
1082 public static List<Node> getOvsdbNodes(DataBroker dataBroker) {
1083 final List<Node> ovsdbNodes = new ArrayList<>();
1084 final InstanceIdentifier<Topology> ovsdbTopoIdentifier = UnimgrMapper.getOvsdbTopologyIid();
1085 final Topology topology = UnimgrUtils.read(dataBroker,
1086 LogicalDatastoreType.OPERATIONAL,
1087 ovsdbTopoIdentifier);
1088 if (topology != null && topology.getNode() != null) {
1089 for (final Node node : topology.getNode()) {
1090 final OvsdbNodeAugmentation ovsdbNodeAugmentation = node.getAugmentation(OvsdbNodeAugmentation.class);
1091 if (ovsdbNodeAugmentation != null) {
1092 ovsdbNodes.add(node);
1100 * Retrieve a list of Uni Nodes from the Configuration DataStore
1101 * @param dataBroker The dataBroker instance to create transactions
1102 * @return A list of Uni Nodes from the Config dataStore
1104 public static List<Node> getUniNodes(DataBroker dataBroker) {
1105 final List<Node> uniNodes = new ArrayList<>();
1106 final InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.getUniTopologyIid();
1107 final Topology topology = read(dataBroker,
1108 LogicalDatastoreType.CONFIGURATION,
1109 topologyInstanceIdentifier);
1110 if (topology != null && topology.getNode() != null) {
1111 for (final Node node : topology.getNode()) {
1112 final UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
1113 if (uniAugmentation != null) {
1122 * Retrieve a list of Uni Nodes on a specific DataStore
1123 * @param dataBroker The dataBroker instance to create transactions
1124 * @param store The store to which to send the read request
1125 * @return A List of UNI Nodes.
1127 public static List<Node> getUniNodes(DataBroker dataBroker,
1128 LogicalDatastoreType store) {
1129 final List<Node> uniNodes = new ArrayList<>();
1130 final InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.getUniTopologyIid();
1131 final Topology topology = read(dataBroker,
1133 topologyInstanceIdentifier);
1134 if (topology != null && topology.getNode() != null) {
1135 for (final Node node : topology.getNode()) {
1136 final UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
1137 if (uniAugmentation != null) {
1146 * Retrieve a list of Unis on a specific DataStore
1147 * @param dataBroker instance to create transactions
1148 * @param store to which send the read request
1149 * @return A List of Unis.
1151 public static List<UniAugmentation> getUnis(DataBroker dataBroker,
1152 LogicalDatastoreType store) {
1153 final List<UniAugmentation> unis = new ArrayList<>();
1154 final InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.getUniTopologyIid();
1155 final Topology topology = read(dataBroker,
1157 topologyInstanceIdentifier);
1158 if (topology != null && topology.getNode() != null) {
1159 for (final Node node : topology.getNode()) {
1160 final UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
1161 if (uniAugmentation != null) {
1162 unis.add(uniAugmentation);
1170 * Retrieve a list of Unis on a specific DataStore
1171 * @param dataBroker instance to create transactions
1172 * @param store to which send the read request
1173 * @param ipAddress of the required Uni
1176 public static UniAugmentation getUni(DataBroker dataBroker,
1177 LogicalDatastoreType store, IpAddress ipAddress) {
1178 final InstanceIdentifier<Topology> topologyInstanceIdentifier = UnimgrMapper.getUniTopologyIid();
1179 final Topology topology = read(dataBroker,
1181 topologyInstanceIdentifier);
1182 if (topology != null && topology.getNode() != null) {
1183 for (final Node node : topology.getNode()) {
1184 final UniAugmentation uniAugmentation = node.getAugmentation(UniAugmentation.class);
1185 if (uniAugmentation != null && uniAugmentation.getIpAddress().getIpv4Address().getValue().equals(ipAddress.getIpv4Address().getValue())) {
1186 return uniAugmentation;
1194 * Read a specific datastore type and return a DataObject as a casted
1195 * class type Object.
1196 * @param dataBroker The dataBroker instance to create transactions
1197 * @param store The store type to query
1198 * @param path The generic path to query
1199 * @return The DataObject as a casted Object
1201 public static <D extends org.opendaylight.yangtools.yang.binding.DataObject> D read(
1202 DataBroker dataBroker,
1203 final LogicalDatastoreType store,
1204 final InstanceIdentifier<D> path) {
1206 final ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
1207 Optional<D> optionalDataObject;
1208 final CheckedFuture<Optional<D>, ReadFailedException> future = transaction.read(store, path);
1210 optionalDataObject = future.checkedGet();
1211 if (optionalDataObject.isPresent()) {
1212 result = optionalDataObject.get();
1214 LOG.debug("{}: Failed to read {}",
1215 Thread.currentThread().getStackTrace()[1], path);
1217 } catch (final ReadFailedException e) {
1218 LOG.warn("Failed to read {} ", path, e);
1220 transaction.close();
1225 * Read a specific node from the Operational Data store by default.
1226 * @param dataBroker The dataBroker instance to create transactions
1227 * @param genericNode The Instance Identifier of the Node
1228 * @return The Optional Node instance
1231 public static final Optional<Node> readNode(DataBroker dataBroker,
1232 InstanceIdentifier<?> genericNode) {
1233 final ReadTransaction read = dataBroker.newReadOnlyTransaction();
1234 final InstanceIdentifier<Node> nodeIid = genericNode.firstIdentifierOf(Node.class);
1235 final CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture =
1236 read.read(LogicalDatastoreType.OPERATIONAL,
1239 return nodeFuture.checkedGet();
1240 } catch (final ReadFailedException e) {
1241 LOG.info("Unable to read node with Iid {}", nodeIid);
1243 return Optional.absent();
1247 * Read a specific Link from a specific datastore
1248 * @param dataBroker The dataBroker instance to create transactions
1249 * @param store The datastore type.
1250 * @param genericNode The Instance Identifier of the Link
1251 * @return An Optional Link instance
1253 public static final Optional<Link> readLink(DataBroker dataBroker,
1254 LogicalDatastoreType store,
1255 InstanceIdentifier<?> genericNode) {
1256 final ReadTransaction read = dataBroker.newReadOnlyTransaction();
1257 final InstanceIdentifier<Link> linkIid = genericNode.firstIdentifierOf(Link.class);
1258 final CheckedFuture<Optional<Link>, ReadFailedException> linkFuture = read.read(store, linkIid);
1260 return linkFuture.checkedGet();
1261 } catch (final ReadFailedException e) {
1262 LOG.info("Unable to read node with Iid {}", linkIid);
1264 return Optional.absent();
1268 * Read a specific node from a specific data store type.
1269 * @param dataBroker The dataBroker instance to create transactions
1270 * @param store The data store type
1271 * @param genericNode The Instance Identifier of a specific Node
1272 * @return An Optional Node instance
1274 public static final Optional<Node> readNode(DataBroker dataBroker,
1275 LogicalDatastoreType store,
1276 InstanceIdentifier<?> genericNode) {
1277 final ReadTransaction read = dataBroker.newReadOnlyTransaction();
1278 final InstanceIdentifier<Node> nodeIid = genericNode.firstIdentifierOf(Node.class);
1279 final CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture = read
1280 .read(store, nodeIid);
1282 return nodeFuture.checkedGet();
1283 } catch (final ReadFailedException e) {
1284 LOG.info("Unable to read node with Iid {}", nodeIid);
1286 return Optional.absent();
1290 * Updates a specific Uni Node on a specific DataStore type
1291 * @param dataStore The datastore type
1292 * @param uniIID The UNI InstanceIdentifier
1293 * @param uni The Uni's data
1294 * @param ovsdbNode The Ovsdb Node
1295 * @param dataBroker The dataBroker instance to create transactions
1296 * @return true if uni is updated
1298 public static boolean updateUniNode(LogicalDatastoreType dataStore,
1299 InstanceIdentifier<?> uniIID,
1300 UniAugmentation uni,
1302 DataBroker dataBroker) {
1303 final InstanceIdentifier<Node> ovsdbNodeIid = UnimgrMapper.getOvsdbNodeIid(ovsdbNode.getNodeId());
1304 final OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
1305 final UniAugmentationBuilder updatedUniBuilder = new UniAugmentationBuilder(uni);
1306 if (ovsdbNodeRef != null) {
1307 updatedUniBuilder.setOvsdbNodeRef(ovsdbNodeRef);
1309 final Optional<Node> optionalNode = readNode(dataBroker,
1310 LogicalDatastoreType.CONFIGURATION,
1312 if (optionalNode.isPresent()) {
1313 final Node node = optionalNode.get();
1314 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
1315 final NodeBuilder nodeBuilder = new NodeBuilder();
1316 nodeBuilder.setKey(node.getKey());
1317 nodeBuilder.setNodeId(node.getNodeId());
1318 nodeBuilder.addAugmentation(UniAugmentation.class, updatedUniBuilder.build());
1319 transaction.put(dataStore, uniIID.firstIdentifierOf(Node.class), nodeBuilder.build());
1320 transaction.submit();
1327 * Update a specific UNI node on a specific datastore type
1328 * @param dataStore The datastore type
1329 * @param uniKey The UNI key
1330 * @param uni The Uni's data
1331 * @param ovsdbNodeIid The Ovsdb Node Instance Identifier
1332 * @param dataBroker The dataBroker instance to create transactions
1333 * @return true if uni is updated
1335 public static boolean updateUniNode(LogicalDatastoreType dataStore,
1336 InstanceIdentifier<?> uniKey,
1337 UniAugmentation uni,
1338 InstanceIdentifier<?> ovsdbNodeIid,
1339 DataBroker dataBroker) {
1340 final OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(ovsdbNodeIid);
1341 final UniAugmentationBuilder updatedUniBuilder = new UniAugmentationBuilder(uni);
1342 if (ovsdbNodeRef != null) {
1343 updatedUniBuilder.setOvsdbNodeRef(ovsdbNodeRef);
1345 final Optional<Node> optionalNode = readNode(dataBroker,
1346 LogicalDatastoreType.CONFIGURATION,
1348 if (optionalNode.isPresent()) {
1349 final Node node = optionalNode.get();
1350 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
1351 final NodeBuilder nodeBuilder = new NodeBuilder();
1352 nodeBuilder.setKey(node.getKey());
1353 nodeBuilder.setNodeId(node.getNodeId());
1354 nodeBuilder.addAugmentation(UniAugmentation.class, updatedUniBuilder.build());
1355 transaction.put(dataStore, uniKey.firstIdentifierOf(Node.class), nodeBuilder.build());
1356 transaction.submit();
1363 * Updates a specific EVC into a specific DataStore type
1364 * @param dataStore The datastore type
1365 * @param evcKey The EVC key
1366 * @param evcAugmentation The EVC's data
1367 * @param sourceUniIid The Source Uni Instance Identifier
1368 * @param destinationUniIid The destination Uni Instance Identifier
1369 * @param dataBroker The dataBroker instance to create transactions
1370 * @return true if evc is updated
1372 public static boolean updateEvcNode(LogicalDatastoreType dataStore,
1373 InstanceIdentifier<?> evcKey,
1374 EvcAugmentation evcAugmentation,
1375 InstanceIdentifier<?> sourceUniIid,
1376 InstanceIdentifier<?> destinationUniIid,
1377 DataBroker dataBroker) {
1378 final EvcAugmentationBuilder updatedEvcBuilder = new EvcAugmentationBuilder(evcAugmentation);
1379 if (sourceUniIid != null && destinationUniIid != null) {
1380 final List<UniSource> sourceList = new ArrayList<UniSource>();
1381 final UniSourceKey sourceKey = evcAugmentation.getUniSource().iterator().next().getKey();
1382 final short sourceOrder = evcAugmentation.getUniSource().iterator().next().getOrder();
1383 final IpAddress sourceIp = evcAugmentation.getUniSource().iterator().next().getIpAddress();
1384 final UniSource uniSource = new UniSourceBuilder()
1385 .setOrder(sourceOrder)
1387 .setIpAddress(sourceIp)
1388 .setUni(sourceUniIid)
1390 sourceList.add(uniSource);
1391 updatedEvcBuilder.setUniSource(sourceList);
1393 final List<UniDest> destinationList = new ArrayList<UniDest>();
1394 final UniDestKey destKey = evcAugmentation.getUniDest().iterator().next().getKey();
1395 final short destOrder = evcAugmentation.getUniDest().iterator().next().getOrder();
1396 final IpAddress destIp = evcAugmentation.getUniDest().iterator().next().getIpAddress();
1397 final UniDest uniDest = new UniDestBuilder()
1398 .setIpAddress(destIp)
1399 .setOrder(destOrder)
1401 .setUni(destinationUniIid)
1403 destinationList.add(uniDest);
1404 updatedEvcBuilder.setUniDest(destinationList);
1405 final Optional<Link> optionalEvcLink = readLink(dataBroker,
1406 LogicalDatastoreType.CONFIGURATION,
1408 if (optionalEvcLink.isPresent()) {
1409 final Link link = optionalEvcLink.get();
1410 final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
1411 final LinkBuilder linkBuilder = new LinkBuilder();
1412 linkBuilder.setKey(link.getKey());
1413 linkBuilder.setLinkId(link.getLinkId());
1414 linkBuilder.setDestination(link.getDestination());
1415 linkBuilder.setSource(link.getSource());
1416 linkBuilder.addAugmentation(EvcAugmentation.class, updatedEvcBuilder.build());
1417 transaction.put(dataStore, evcKey.firstIdentifierOf(Link.class), linkBuilder.build());
1418 transaction.submit();
1421 LOG.info("EvcLink is not present: " + optionalEvcLink.get().getKey());
1424 LOG.info("Invalid instance identifiers for sourceUni and destUni.");