2 * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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
9 package org.opendaylight.vpnservice.mdsalutil;
11 import java.math.BigInteger;
12 import java.util.ArrayList;
13 import java.util.HashMap;
14 import java.util.List;
16 import java.util.concurrent.ConcurrentHashMap;
17 import java.util.concurrent.ExecutionException;
18 import java.util.concurrent.LinkedBlockingQueue;
20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
21 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
24 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopVlanActionCaseBuilder;
25 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.vlan.action._case.PopVlanActionBuilder;
26 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
27 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowModFlags;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Instructions;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCase;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteMetadataCaseBuilder;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActions;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.write.metadata._case.WriteMetadataBuilder;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.BucketId;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.Buckets;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.BucketsBuilder;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.BucketBuilder;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInputBuilder;
69 import org.opendaylight.yangtools.yang.binding.DataObject;
70 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
71 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
72 import org.opendaylight.yangtools.yang.binding.DataObject;
73 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
74 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
75 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
76 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
77 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
78 import org.slf4j.Logger;
79 import org.slf4j.LoggerFactory;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
81 import org.opendaylight.controller.liblldp.HexEncode;
82 import com.google.common.base.Joiner;
83 import com.google.common.base.Optional;
84 import com.google.common.primitives.Bytes;
85 import com.google.common.primitives.Ints;
86 import com.google.common.util.concurrent.CheckedFuture;
88 public class MDSALUtil {
90 public static final String NODE_PREFIX = "openflow";
91 public static final String SEPARATOR = ":";
92 private static final Buckets EMPTY_Buckets = new BucketsBuilder().build();
93 private static final Instructions EMPTY_Instructions = new InstructionsBuilder().setInstruction(
94 new ArrayList<Instruction>()).build();
95 private static final Match EMPTY_Matches = new MatchBuilder().build();
96 private static final Logger logger = LoggerFactory.getLogger(MDSALUtil.class);
98 public static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, String flowId, int priority, String flowName,
99 int idleTimeOut, int hardTimeOut, BigInteger cookie, List<MatchInfo> listMatchInfo,
100 List<InstructionInfo> listInstructionInfo) {
102 FlowEntity flowEntity = new FlowEntity(dpnId);
104 flowEntity.setTableId(tableId);
105 flowEntity.setFlowId(flowId);
106 flowEntity.setPriority(priority);
107 flowEntity.setFlowName(flowName);
108 flowEntity.setIdleTimeOut(idleTimeOut);
109 flowEntity.setHardTimeOut(hardTimeOut);
110 flowEntity.setCookie(cookie);
111 flowEntity.setMatchInfoList(listMatchInfo);
112 flowEntity.setInstructionInfoList(listInstructionInfo);
117 // TODO: CHECK IF THIS IS USED
118 public static Flow buildFlow(short tableId, String flowId, int priority, String flowName, int idleTimeOut,
119 int hardTimeOut, BigInteger cookie, List<MatchInfo> listMatchInfo, List<InstructionInfo> listInstructionInfo) {
120 return MDSALUtil.buildFlow(tableId, flowId, priority, flowName, idleTimeOut, hardTimeOut, cookie,
121 listMatchInfo, listInstructionInfo, true);
124 public static Flow buildFlow(short tableId, String flowId, int priority, String flowName, int idleTimeOut,
125 int hardTimeOut, BigInteger cookie, List<MatchInfo> listMatchInfo,
126 List<InstructionInfo> listInstructionInfo, boolean isStrict) {
127 FlowKey key = new FlowKey(new FlowId(flowId));
128 return new FlowBuilder().setMatch(buildMatches(listMatchInfo)).setKey(key)
129 .setPriority(Integer.valueOf(priority)).setInstructions(buildInstructions(listInstructionInfo))
130 .setBarrier(false).setInstallHw(true).setHardTimeout(hardTimeOut).setIdleTimeout(idleTimeOut)
131 .setFlowName(flowName).setTableId(Short.valueOf(tableId)).setStrict(isStrict)
132 .setCookie(new FlowCookie(cookie)).build();
135 public static Flow buildFlowNew(short tableId, String flowId, int priority, String flowName, int idleTimeOut,
136 int hardTimeOut, BigInteger cookie, List<MatchInfo> listMatchInfo, List<Instruction> listInstructionInfo) {
137 return MDSALUtil.buildFlowNew(tableId, flowId, priority, flowName, idleTimeOut, hardTimeOut, cookie,
138 listMatchInfo, listInstructionInfo, true);
141 private static Flow buildFlowNew(short tableId, String flowId, int priority, String flowName, int idleTimeOut,
142 int hardTimeOut, BigInteger cookie, List<MatchInfo> listMatchInfo,
143 List<Instruction> listInstructionInfo, boolean isStrict) {
144 FlowKey key = new FlowKey(new FlowId(flowId));
145 return new FlowBuilder().setMatch(buildMatches(listMatchInfo)).setKey(key)
146 .setPriority(Integer.valueOf(priority)).setInstructions(new InstructionsBuilder().setInstruction(listInstructionInfo).build())
147 .setBarrier(false).setInstallHw(true).setHardTimeout(hardTimeOut).setIdleTimeout(idleTimeOut)
148 .setFlowName(flowName).setTableId(Short.valueOf(tableId)).setStrict(isStrict)
149 .setCookie(new FlowCookie(cookie)).build();
152 public static GroupEntity buildGroupEntity(BigInteger dpnId, long groupId, String groupName, GroupTypes groupType,
153 List<BucketInfo> listBucketInfo) {
155 GroupEntity groupEntity = new GroupEntity(dpnId);
157 groupEntity.setGroupId(groupId);
158 groupEntity.setGroupName(groupName);
159 groupEntity.setGroupType(groupType);
160 groupEntity.setBucketInfoList(listBucketInfo);
165 public static TransmitPacketInput getPacketOutDefault(List<ActionInfo> actionInfos, byte[] payload, BigInteger dpnId) {
166 return new TransmitPacketInputBuilder()
167 .setAction(buildActions(actionInfos))
170 new NodeRef(InstanceIdentifier.builder(Nodes.class)
171 .child(Node.class, new NodeKey(new NodeId("openflow:" + dpnId))).toInstance()))
172 .setIngress(getDefaultNodeConnRef(dpnId)).setEgress(getDefaultNodeConnRef(dpnId)).build();
175 public static TransmitPacketInput getPacketOut(List<ActionInfo> actionInfos, byte[] payload, long dpnId,
176 NodeConnectorRef ingress) {
177 return new TransmitPacketInputBuilder()
178 .setAction(buildActions(actionInfos))
181 new NodeRef(InstanceIdentifier.builder(Nodes.class)
182 .child(Node.class, new NodeKey(new NodeId("openflow:" + dpnId))).toInstance()))
183 .setIngress(ingress).setEgress(ingress).build();
186 private static List<Action> buildActions(List<ActionInfo> actions) {
187 List<Action> actionsList = new ArrayList<Action>();
188 for (ActionInfo actionInfo : actions) {
189 actionsList.add(actionInfo.buildAction());
194 public static String longToIp(long ip, long mask) {
195 StringBuilder sb = new StringBuilder(15);
196 Joiner joiner = Joiner.on('.');
198 joiner.appendTo(sb, Bytes.asList(Ints.toByteArray((int) ip)));
200 sb.append("/" + mask);
202 return sb.toString();
205 protected static Buckets buildBuckets(List<BucketInfo> listBucketInfo) {
207 if (listBucketInfo != null) {
208 BucketsBuilder bucketsBuilder = new BucketsBuilder();
209 List<Bucket> bucketList = new ArrayList<Bucket>();
211 for (BucketInfo bucketInfo : listBucketInfo) {
212 BucketBuilder bucketBuilder = new BucketBuilder();
213 List<Action> actionsList = new ArrayList<Action>();
215 bucketInfo.buildAndAddActions(actionsList);
216 bucketBuilder.setAction(actionsList);
217 bucketBuilder.setWeight(bucketInfo.getWeight());
218 bucketBuilder.setBucketId(new BucketId(i++));
219 bucketBuilder.setWeight(bucketInfo.getWeight()).setWatchPort(bucketInfo.getWatchPort())
220 .setWatchGroup(bucketInfo.getWatchGroup());
221 bucketList.add(bucketBuilder.build());
224 bucketsBuilder.setBucket(bucketList);
225 return bucketsBuilder.build();
228 return EMPTY_Buckets;
231 protected static Instructions buildInstructions(List<InstructionInfo> listInstructionInfo) {
232 if (listInstructionInfo != null) {
233 List<Instruction> instructions = new ArrayList<Instruction>();
234 int instructionKey = 0;
236 for (InstructionInfo instructionInfo : listInstructionInfo) {
237 instructions.add(instructionInfo.buildInstruction(instructionKey));
241 return new InstructionsBuilder().setInstruction(instructions).build();
244 return EMPTY_Instructions;
247 protected static Match buildMatches(List<MatchInfo> listMatchInfo) {
248 if (listMatchInfo != null) {
249 MatchBuilder matchBuilder = new MatchBuilder();
250 Map<Class<?>, Object> mapMatchBuilder = new HashMap<Class<?>, Object>();
252 for (MatchInfo matchInfo : listMatchInfo) {
253 matchInfo.createInnerMatchBuilder(mapMatchBuilder);
256 for (MatchInfo matchInfo : listMatchInfo) {
257 matchInfo.setMatch(matchBuilder, mapMatchBuilder);
260 return matchBuilder.build();
263 return EMPTY_Matches;
266 // TODO: Check the port const
267 public static NodeConnectorRef getDefaultNodeConnRef(BigInteger nDpId) {
268 return getNodeConnRef(NODE_PREFIX + SEPARATOR + nDpId, "0xfffffffd");
271 public static NodeConnectorRef getNodeConnRef(BigInteger nDpId, String port) {
272 return getNodeConnRef(NODE_PREFIX + SEPARATOR + nDpId, port);
275 public static NodeConnectorRef getNodeConnRef(String sNodeId, String port) {
276 String sNodeConnectorKey;
280 NodeConnectorId nodeConnectorId;
281 NodeConnectorKey nodeConnectorKey;
282 InstanceIdentifierBuilder<Nodes> nodesInstanceIdentifierBuilder;
283 InstanceIdentifierBuilder<Node> nodeInstanceIdentifierBuilder;
284 InstanceIdentifierBuilder<NodeConnector> nodeConnectorInstanceIdentifierBuilder;
285 InstanceIdentifier<NodeConnector> nodeConnectorInstanceIdentifier;
286 NodeConnectorRef nodeConnectorRef;
288 sbTmp = new StringBuilder();
290 sbTmp.append(sNodeId);
291 sbTmp.append(SEPARATOR);
294 sNodeConnectorKey = sbTmp.toString();
295 nodeConnectorId = new NodeConnectorId(sNodeConnectorKey);
296 nodeConnectorKey = new NodeConnectorKey(nodeConnectorId);
298 nodeId = new NodeId(sNodeId);
299 nodeKey = new NodeKey(nodeId);
301 nodesInstanceIdentifierBuilder = InstanceIdentifier.<Nodes> builder(Nodes.class);
302 nodeInstanceIdentifierBuilder = nodesInstanceIdentifierBuilder.<Node, NodeKey> child(Node.class, nodeKey);
303 nodeConnectorInstanceIdentifierBuilder = nodeInstanceIdentifierBuilder.<NodeConnector, NodeConnectorKey> child(
304 NodeConnector.class, nodeConnectorKey);
305 nodeConnectorInstanceIdentifier = nodeConnectorInstanceIdentifierBuilder.toInstance();
306 nodeConnectorRef = new NodeConnectorRef(nodeConnectorInstanceIdentifier);
307 return nodeConnectorRef;
310 public static BigInteger getDpnIdFromNodeName(NodeId nodeId) {
311 return getDpnIdFromNodeName(nodeId.getValue());
314 public static BigInteger getDpnIdFromNodeName(String sMdsalNodeName) {
315 String sDpId = sMdsalNodeName.substring(sMdsalNodeName.lastIndexOf(":") + 1);
316 return new BigInteger(sDpId);
319 public static long getOfPortNumberFromPortName(NodeConnectorId nodeConnectorId) {
320 return getOfPortNumberFromPortName(nodeConnectorId.getValue());
323 public static long getDpnIdFromPortName(NodeConnectorId nodeConnectorId) {
324 String ofPortName = nodeConnectorId.getValue();
325 return Long.parseLong(ofPortName.substring(ofPortName.indexOf(":")+1,
326 ofPortName.lastIndexOf(":")));
329 public static long getOfPortNumberFromPortName(String sMdsalPortName) {
330 String sPortNumber = sMdsalPortName.substring(sMdsalPortName.lastIndexOf(":") + 1);
331 return Long.parseLong(sPortNumber);
334 public static TransmitPacketInput getPacketOut(List<ActionInfo> actionInfos, byte[] payload, BigInteger dpnId,
335 NodeConnectorRef nodeConnRef) {
336 // TODO Auto-generated method stub
340 public static Instruction buildAndGetPopVlanActionInstruction(int actionKey, int instructionKey) {
341 Action popVlanAction = new ActionBuilder().setAction(
342 new PopVlanActionCaseBuilder().setPopVlanAction(new PopVlanActionBuilder().build()).build())
343 .setKey(new ActionKey(actionKey)).build();
344 List<Action> listAction = new ArrayList<Action> ();
345 listAction.add(popVlanAction);
346 ApplyActions applyActions = new ApplyActionsBuilder().setAction(listAction).build();
347 ApplyActionsCase applyActionsCase = new ApplyActionsCaseBuilder().setApplyActions(applyActions).build();
348 InstructionBuilder instructionBuilder = new InstructionBuilder();
350 instructionBuilder.setInstruction(applyActionsCase);
351 instructionBuilder.setKey(new InstructionKey(instructionKey));
352 return instructionBuilder.build();
355 public static Instruction buildAndGetWriteMetadaInstruction(BigInteger metadata,
356 BigInteger mask, int instructionKey) {
357 return new InstructionBuilder()
359 new WriteMetadataCaseBuilder().setWriteMetadata(
360 new WriteMetadataBuilder().setMetadata(metadata).setMetadataMask(mask).build())
361 .build()).setKey(new InstructionKey(instructionKey)).build();
364 public static <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
365 InstanceIdentifier<T> path, DataBroker broker) {
367 ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
369 Optional<T> result = Optional.absent();
371 result = tx.read(datastoreType, path).get();
372 } catch (Exception e) {
373 logger.error("An error occured while reading data from the path {} with the exception {}", path, e);
378 public static <T extends DataObject> Optional<T> read(DataBroker broker,
379 LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
381 ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
383 Optional<T> result = Optional.absent();
385 result = tx.read(datastoreType, path).get();
386 } catch (Exception e) {
387 throw new RuntimeException(e);
392 public static <T extends DataObject> void syncWrite(DataBroker broker,
393 LogicalDatastoreType datastoreType, InstanceIdentifier<T> path,
395 WriteTransaction tx = broker.newWriteOnlyTransaction();
396 tx.put(datastoreType, path, data, true);
397 CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
400 } catch (InterruptedException | ExecutionException e) {
401 logger.error("Error writing to datastore (path, data) : ({}, {})", path, data);
402 throw new RuntimeException(e.getMessage());
406 public static <T extends DataObject> void syncUpdate(DataBroker broker,
407 LogicalDatastoreType datastoreType, InstanceIdentifier<T> path,
409 WriteTransaction tx = broker.newWriteOnlyTransaction();
410 tx.merge(datastoreType, path, data, true);
411 CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
414 } catch (InterruptedException | ExecutionException e) {
415 logger.error("Error writing to datastore (path, data) : ({}, {})", path, data);
416 throw new RuntimeException(e.getMessage());
420 public static <T extends DataObject> void syncDelete(DataBroker broker,
421 LogicalDatastoreType datastoreType, InstanceIdentifier<T> obj) {
422 WriteTransaction tx = broker.newWriteOnlyTransaction();
423 tx.delete(datastoreType, obj);
424 CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
427 } catch (InterruptedException | ExecutionException e) {
428 logger.error("Error deleting from datastore (path) : ({})", obj);
429 throw new RuntimeException(e.getMessage());
433 public static byte[] getMacAddressForNodeConnector(DataBroker broker,
434 InstanceIdentifier<NodeConnector> nodeConnectorId) {
435 Optional<NodeConnector> optNc = MDSALDataStoreUtils.read(broker,
436 LogicalDatastoreType.OPERATIONAL, nodeConnectorId);
437 if(optNc.isPresent()) {
438 NodeConnector nc = optNc.get();
439 FlowCapableNodeConnector fcnc = nc.getAugmentation(FlowCapableNodeConnector.class);
440 MacAddress macAddress = fcnc.getHardwareAddress();
441 return HexEncode.bytesFromHexString(macAddress.getValue());
446 public static NodeId getNodeIdFromNodeConnectorId(NodeConnectorId ncId) {
447 return new NodeId(ncId.getValue().substring(0,
448 ncId.getValue().lastIndexOf(":")));
451 public static String getInterfaceName(NodeConnectorRef ref, DataBroker dataBroker) {
452 NodeConnectorId nodeConnectorId = getNodeConnectorId(dataBroker, ref);
453 NodeId nodeId = getNodeIdFromNodeConnectorId(nodeConnectorId);
454 InstanceIdentifier<NodeConnector> ncIdentifier = InstanceIdentifier
455 .builder(Nodes.class)
456 .child(Node.class, new NodeKey(nodeId))
457 .child(NodeConnector.class,
458 new NodeConnectorKey(nodeConnectorId)).build();
460 Optional<NodeConnector> nodeConnectorOptional = read(
462 LogicalDatastoreType.OPERATIONAL, ncIdentifier);
463 if (!nodeConnectorOptional.isPresent()) {
466 NodeConnector nc = nodeConnectorOptional.get();
467 FlowCapableNodeConnector fc = nc
468 .getAugmentation(FlowCapableNodeConnector.class);
472 public static NodeConnectorId getNodeConnectorId(DataBroker dataBroker,
473 NodeConnectorRef ref) {
474 Optional<NodeConnector> nc = (Optional<NodeConnector>) read(
476 LogicalDatastoreType.CONFIGURATION, ref.getValue());
477 return nc.get().getId();