2 * Copyright (c) 2015, 2017 China Telecom Beijing Research Institute 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.ovsdb.hwvtepsouthbound.transact;
11 import com.google.common.base.Preconditions;
12 import java.util.Collection;
13 import java.util.Collections;
14 import java.util.HashMap;
15 import java.util.List;
17 import java.util.Map.Entry;
18 import java.util.Optional;
20 import java.util.concurrent.ConcurrentHashMap;
21 import org.apache.commons.lang3.tuple.Pair;
22 import org.opendaylight.mdsal.binding.api.DataBroker;
23 import org.opendaylight.mdsal.binding.api.DataTreeModification;
24 import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
25 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
26 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
27 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepDeviceInfo;
28 import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepSouthboundUtil;
29 import org.opendaylight.ovsdb.lib.notation.UUID;
30 import org.opendaylight.ovsdb.utils.mdsal.utils.ControllerMdsalUtils;
31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.EncapsulationTypeBase;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepNodeName;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentation;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Acls;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacs;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalMcastMacsKey;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacs;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LocalUcastMacsKey;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalRouters;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalRoutersKey;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitches;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.LogicalSwitchesKey;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacs;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteMcastMacsKey;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacs;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.RemoteUcastMacsKey;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.Switches;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.Tunnels;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.physical._switch.attributes.TunnelsKey;
54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
55 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
56 import org.opendaylight.yangtools.yang.binding.Identifiable;
57 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
58 import org.slf4j.Logger;
59 import org.slf4j.LoggerFactory;
61 //TODO: need to be optimized, get entry by iid not name
62 public class HwvtepOperationalState {
64 private static final Logger LOG = LoggerFactory.getLogger(HwvtepOperationalState.class);
66 private final Map<InstanceIdentifier<Node>, Node> operationalNodes = new HashMap<>();
67 private ReadWriteTransaction transaction;
68 HashMap<InstanceIdentifier<TerminationPoint>, UUID> inflightLocators = new HashMap<>();
69 private final HwvtepDeviceInfo deviceInfo;
70 private final HwvtepConnectionInstance connectionInstance;
71 private final Map<Class<? extends Identifiable>, Map<InstanceIdentifier, UUID>> currentTxUUIDs =
72 new ConcurrentHashMap<>();
73 private final Map<Class<? extends Identifiable>, Map<InstanceIdentifier, Boolean>> currentTxDeletedKeys =
74 new ConcurrentHashMap<>();
76 /* stores the modified and deleted data for each child type of each node id
77 Map<nodeid , Pair < updated, deleted >
78 each updated/ deleted contains Map < child type, List<ChildData>>
79 child type is the child of hwvtep Global augmentation
81 private Map<InstanceIdentifier<Node>,
82 Pair<Map<Class<? extends Identifiable>, List<Identifiable>>,
83 Map<Class<? extends Identifiable>, List<Identifiable>>>> modifiedData = new HashMap<>();
84 private boolean inReconciliation = false;
85 private final DataBroker db;
86 private final Collection<DataTreeModification<Node>> changes;
87 long transactionId = 0;
89 public HwvtepOperationalState(DataBroker db, HwvtepConnectionInstance connectionInstance,
90 Collection<DataTreeModification<Node>> changes) {
91 this.connectionInstance = connectionInstance;
92 this.deviceInfo = connectionInstance.getDeviceInfo();
94 this.changes = changes;
95 this.transaction = db.newReadWriteTransaction();
98 public HwvtepOperationalState(HwvtepConnectionInstance connectionInstance) {
99 this.connectionInstance = connectionInstance;
100 this.deviceInfo = connectionInstance.getDeviceInfo();
101 this.db = connectionInstance.getDataBroker();
103 transaction = connectionInstance.getDataBroker().newReadWriteTransaction();
104 Optional<Node> readNode = new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL,
105 connectionInstance.getInstanceIdentifier());
106 if (readNode.isPresent()) {
107 operationalNodes.put(connectionInstance.getInstanceIdentifier(), readNode.get());
111 public HwvtepOperationalState(final DataBroker db,
112 final HwvtepConnectionInstance connectionInstance,
113 final Collection<DataTreeModification<Node>> changes,
114 final Node globalOperNode,
116 this(db, connectionInstance, changes);
117 operationalNodes.put(connectionInstance.getInstanceIdentifier(), globalOperNode);
118 HwvtepGlobalAugmentation globalAugmentation = globalOperNode.augmentation(HwvtepGlobalAugmentation.class);
119 if (globalAugmentation != null) {
120 if (!HwvtepSouthboundUtil.isEmpty(globalAugmentation.getSwitches())) {
121 operationalNodes.put((InstanceIdentifier<Node>)
122 globalAugmentation.getSwitches().get(0).getSwitchRef().getValue(), psNode);
127 public void readOperationalNodes() {
128 if (inReconciliation) {
131 if (changes == null) {
132 LOG.warn("Could not read operational nodes for {} as changes is",
133 connectionInstance.getNodeId().getValue());
136 Map<InstanceIdentifier<Node>, Node> nodeCreateOrUpdate =
137 TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, Node.class);
138 if (nodeCreateOrUpdate != null) {
139 transaction = db.newReadWriteTransaction();
140 for (Entry<InstanceIdentifier<Node>, Node> entry: nodeCreateOrUpdate.entrySet()) {
141 Optional<Node> readNode = new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL,
143 //add related globalNode or physicalSwitchNode to operationalNodes map
144 //for example, when creating physical port, logical switch is needed
145 //but logical switch is in HwvtepGlobalAugmentation rather than PhysicalSwitchAugmentation
146 if (readNode.isPresent()) {
147 operationalNodes.put(entry.getKey(), readNode.get());
148 HwvtepGlobalAugmentation hgAugmentation =
149 readNode.get().augmentation(HwvtepGlobalAugmentation.class);
150 PhysicalSwitchAugmentation psAugmentation =
151 readNode.get().augmentation(PhysicalSwitchAugmentation.class);
152 if (hgAugmentation != null && hgAugmentation.getSwitches() != null) {
153 for (Switches pswitch : hgAugmentation.getSwitches()) {
154 @SuppressWarnings("unchecked")
155 InstanceIdentifier<Node> psNodeIid =
156 (InstanceIdentifier<Node>) pswitch.getSwitchRef().getValue();
157 Optional<Node> psNode =
158 new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL, psNodeIid);
159 if (psNode.isPresent()) {
160 operationalNodes.put(psNodeIid, psNode.get());
164 if (psAugmentation != null) {
165 @SuppressWarnings("unchecked")
166 InstanceIdentifier<Node> hgNodeIid =
167 (InstanceIdentifier<Node>) psAugmentation.getManagedBy().getValue();
168 Optional<Node> hgNode = new ControllerMdsalUtils(db).readOptional(
169 LogicalDatastoreType.OPERATIONAL, hgNodeIid);
170 if (hgNode.isPresent()) {
171 operationalNodes.put(hgNodeIid, hgNode.get());
179 public Optional<Node> getGlobalNode(InstanceIdentifier<?> iid) {
180 InstanceIdentifier<Node> nodeIid = iid.firstIdentifierOf(Node.class);
181 return Optional.ofNullable(operationalNodes.get(nodeIid));
184 public Optional<HwvtepGlobalAugmentation> getHwvtepGlobalAugmentation(InstanceIdentifier<?> iid) {
185 Preconditions.checkNotNull(iid);
186 Optional<Node> nodeOptional = getGlobalNode(iid);
187 if (nodeOptional.isPresent()) {
188 return Optional.ofNullable(nodeOptional.get().augmentation(HwvtepGlobalAugmentation.class));
190 return Optional.empty();
193 public Optional<PhysicalSwitchAugmentation> getPhysicalSwitchAugmentation(InstanceIdentifier<?> iid) {
194 Preconditions.checkNotNull(iid);
195 Optional<Node> nodeOptional = getGlobalNode(iid);
196 if (nodeOptional.isPresent()) {
197 return Optional.ofNullable(nodeOptional.get().augmentation(PhysicalSwitchAugmentation.class));
199 return Optional.empty();
202 public Optional<List<TerminationPoint>> getTerminationPointList(InstanceIdentifier<?> iid) {
203 Preconditions.checkNotNull(iid);
204 Optional<Node> nodeOptional = getGlobalNode(iid);
205 if (nodeOptional.isPresent() && nodeOptional.get().getTerminationPoint() != null) {
206 return Optional.ofNullable(nodeOptional.get().getTerminationPoint());
208 return Optional.empty();
211 public Optional<LogicalSwitches> getLogicalSwitches(InstanceIdentifier<?> iid,
212 LogicalSwitchesKey logicalSwitchesKey) {
213 Preconditions.checkNotNull(iid);
214 Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
215 if (nodeOptional.isPresent()) {
216 HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
217 List<LogicalSwitches> lswitchList = null;
218 if (hgAugmentation != null) {
219 lswitchList = hgAugmentation.getLogicalSwitches();
221 if (lswitchList != null) {
222 for (LogicalSwitches lswitch: lswitchList) {
223 if (lswitch.key().equals(logicalSwitchesKey)) {
224 return Optional.ofNullable(lswitch);
229 return Optional.empty();
232 public Optional<LogicalSwitches> getLogicalSwitches(InstanceIdentifier<LogicalSwitches> iid) {
233 return new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL, iid);
236 public Optional<Tunnels> getTunnels(InstanceIdentifier<?> iid, TunnelsKey tunnelsKey) {
237 Preconditions.checkNotNull(iid);
238 Optional<PhysicalSwitchAugmentation> psOptional = getPhysicalSwitchAugmentation(iid);
239 if (psOptional.isPresent()) {
240 PhysicalSwitchAugmentation psAugmentation = psOptional.get();
241 List<Tunnels> tunnelList = null;
242 if (psAugmentation != null) {
243 tunnelList = psAugmentation.getTunnels();
245 if (tunnelList != null) {
246 for (Tunnels tunnel: tunnelList) {
247 if (tunnel.key().equals(tunnelsKey)) {
248 return Optional.ofNullable(tunnel);
253 return Optional.empty();
256 public Optional<Tunnels> getTunnels(InstanceIdentifier<Tunnels> iid) {
257 Optional<Tunnels> tunnels = new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL, iid);
261 public Optional<HwvtepPhysicalPortAugmentation> getPhysicalPortAugmentation(InstanceIdentifier<?> iid,
262 HwvtepNodeName hwvtepNodeName) {
263 Preconditions.checkNotNull(iid);
264 Optional<List<TerminationPoint>> nodeOptional = getTerminationPointList(iid);
265 if (nodeOptional.isPresent()) {
266 List<TerminationPoint> tpList = nodeOptional.get();
267 for (TerminationPoint tp : tpList) {
268 HwvtepPhysicalPortAugmentation hppAugmentation =
269 tp.augmentation(HwvtepPhysicalPortAugmentation.class);
270 if (hppAugmentation != null && hppAugmentation.getHwvtepNodeName().equals(hwvtepNodeName)) {
271 return Optional.ofNullable(hppAugmentation);
275 return Optional.empty();
278 public Optional<HwvtepPhysicalLocatorAugmentation> getPhysicalLocatorAugmentation(InstanceIdentifier<?> iid,
279 IpAddress dstIp, Class<? extends EncapsulationTypeBase> encapType) {
280 Preconditions.checkNotNull(iid);
281 Optional<List<TerminationPoint>> nodeOptional = getTerminationPointList(iid);
282 if (nodeOptional.isPresent()) {
283 List<TerminationPoint> tpList = nodeOptional.get();
284 for (TerminationPoint tp : tpList) {
285 HwvtepPhysicalLocatorAugmentation hppAugmentation =
286 tp.augmentation(HwvtepPhysicalLocatorAugmentation.class);
287 if (hppAugmentation != null && hppAugmentation.getDstIp().equals(dstIp)
288 && hppAugmentation.getEncapsulationType().equals(encapType)) {
289 return Optional.ofNullable(hppAugmentation);
293 return Optional.empty();
296 public Optional<HwvtepPhysicalLocatorAugmentation>
297 getPhysicalLocatorAugmentation(InstanceIdentifier<TerminationPoint> iid) {
298 Optional<TerminationPoint> tp =
299 new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL, iid);
300 if (tp.isPresent()) {
301 return Optional.ofNullable(tp.get().augmentation(HwvtepPhysicalLocatorAugmentation.class));
303 return Optional.empty();
306 public Optional<LocalMcastMacs> getLocalMcastMacs(InstanceIdentifier<?> iid, LocalMcastMacsKey key) {
307 Preconditions.checkNotNull(iid);
308 Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
309 if (nodeOptional.isPresent()) {
310 HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
311 List<LocalMcastMacs> macList = null;
312 if (hgAugmentation != null) {
313 macList = hgAugmentation.getLocalMcastMacs();
315 if (macList != null) {
316 for (LocalMcastMacs mac: macList) {
317 if (mac.key().equals(key)) {
318 return Optional.ofNullable(mac);
323 return Optional.empty();
326 public Optional<RemoteMcastMacs> getRemoteMcastMacs(InstanceIdentifier<?> iid, RemoteMcastMacsKey key) {
327 Preconditions.checkNotNull(iid);
328 Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
329 if (nodeOptional.isPresent()) {
330 HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
331 List<RemoteMcastMacs> macList = null;
332 if (hgAugmentation != null) {
333 macList = hgAugmentation.getRemoteMcastMacs();
335 if (macList != null) {
336 for (RemoteMcastMacs mac: macList) {
337 if (mac.key().equals(key)) {
338 return Optional.ofNullable(mac);
343 return Optional.empty();
346 public Optional<LocalUcastMacs> getLocalUcastMacs(InstanceIdentifier<?> iid, LocalUcastMacsKey key) {
347 Preconditions.checkNotNull(iid);
348 Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
349 if (nodeOptional.isPresent()) {
350 HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
351 List<LocalUcastMacs> macList = null;
352 if (hgAugmentation != null) {
353 macList = hgAugmentation.getLocalUcastMacs();
355 if (macList != null) {
356 for (LocalUcastMacs mac: macList) {
357 if (mac.key().equals(key)) {
358 return Optional.ofNullable(mac);
363 return Optional.empty();
366 public Optional<RemoteUcastMacs> getRemoteUcastMacs(InstanceIdentifier<?> iid, RemoteUcastMacsKey key) {
367 Preconditions.checkNotNull(iid);
368 Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
369 if (nodeOptional.isPresent()) {
370 HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
371 List<RemoteUcastMacs> macList = null;
372 if (hgAugmentation != null) {
373 macList = hgAugmentation.getRemoteUcastMacs();
375 if (macList != null) {
376 for (RemoteUcastMacs mac: macList) {
377 if (mac.key().equals(key)) {
378 return Optional.ofNullable(mac);
383 return Optional.empty();
386 public Optional<LogicalRouters> getLogicalRouters(final InstanceIdentifier<?> iid,
387 final LogicalRoutersKey logicalRoutersKey) {
388 Preconditions.checkNotNull(iid);
389 Optional<HwvtepGlobalAugmentation> nodeOptional = getHwvtepGlobalAugmentation(iid);
390 if (nodeOptional.isPresent()) {
391 HwvtepGlobalAugmentation hgAugmentation = nodeOptional.get();
392 if (hgAugmentation != null && hgAugmentation.getLogicalRouters() != null) {
393 for (LogicalRouters lrouter: hgAugmentation.getLogicalRouters()) {
394 if (lrouter.key().equals(logicalRoutersKey)) {
395 return Optional.ofNullable(lrouter);
400 return Optional.empty();
403 public Optional<Acls> getAcls(InstanceIdentifier<Acls> iid) {
404 Optional<Acls> acl = new ControllerMdsalUtils(db).readOptional(LogicalDatastoreType.OPERATIONAL, iid);
408 public ReadWriteTransaction getReadWriteTransaction() {
412 public void setPhysicalLocatorInFlight(InstanceIdentifier<TerminationPoint> iid,
414 inflightLocators.put(iid, uuid);
417 public UUID getPhysicalLocatorInFlight(InstanceIdentifier<TerminationPoint> iid) {
418 return inflightLocators.get(iid);
421 public HwvtepConnectionInstance getConnectionInstance() {
422 return connectionInstance;
425 public HwvtepDeviceInfo getDeviceInfo() {
429 public void updateCurrentTxData(Class<? extends Identifiable> cls, InstanceIdentifier key, UUID uuid) {
430 HwvtepSouthboundUtil.updateData(currentTxUUIDs, cls, key, uuid);
433 public void updateCurrentTxDeleteData(Class<? extends Identifiable> cls, InstanceIdentifier key) {
434 HwvtepSouthboundUtil.updateData(currentTxDeletedKeys, cls, key, Boolean.TRUE);
437 public UUID getUUIDFromCurrentTx(Class<? extends Identifiable> cls, InstanceIdentifier key) {
438 return HwvtepSouthboundUtil.getData(currentTxUUIDs, cls, key);
441 public boolean isKeyPartOfCurrentTx(Class<? extends Identifiable> cls, InstanceIdentifier key) {
442 return HwvtepSouthboundUtil.containsKey(currentTxUUIDs, cls, key);
445 public Set<InstanceIdentifier> getDeletedKeysInCurrentTx(Class<? extends Identifiable> cls) {
446 if (currentTxDeletedKeys.containsKey(cls)) {
447 return currentTxDeletedKeys.get(cls).keySet();
449 return Collections.EMPTY_SET;
452 public List<? extends Identifiable> getUpdatedData(final InstanceIdentifier<Node> key,
453 final Class<? extends Identifiable> cls) {
454 List<Identifiable> result = null;
455 if (modifiedData.get(key) != null && modifiedData.get(key).getLeft() != null) {
456 result = modifiedData.get(key).getLeft().get(cls);
458 if (result == null) {
459 result = Collections.EMPTY_LIST;
464 public List<? extends Identifiable> getDeletedData(final InstanceIdentifier<Node> key,
465 final Class<? extends Identifiable> cls) {
466 List<Identifiable> result = null;
467 if (modifiedData.get(key) != null && modifiedData.get(key).getRight() != null) {
468 result = modifiedData.get(key).getRight().get(cls);
470 if (result == null) {
471 result = Collections.EMPTY_LIST;
476 public void setModifiedData(final Map<InstanceIdentifier<Node>,
477 Pair<Map<Class<? extends Identifiable>, List<Identifiable>>,
478 Map<Class<? extends Identifiable>, List<Identifiable>>>> modifiedData) {
479 this.modifiedData = modifiedData;
482 public boolean isInReconciliation() {
483 return inReconciliation;
486 public void setInReconciliation(boolean inReconciliation) {
487 this.inReconciliation = inReconciliation;
490 public DataBroker getDataBroker() {
495 public void clearIntransitKeys() {
496 currentTxUUIDs.forEach((cls, map) -> {
497 map.forEach((iid, uuid) -> deviceInfo.clearInTransit(cls, iid));
499 currentTxDeletedKeys.forEach((cls, map) -> {
500 map.forEach((iid, val) -> deviceInfo.clearInTransit(cls, iid));
502 currentTxUUIDs.clear();
503 currentTxDeletedKeys.clear();
504 deviceInfo.onOperDataAvailable();
507 public long getTransactionId() {
508 return transactionId;