/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
+
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.ovsdb.southbound.SouthboundUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class DataChangesManagedByOvsdbNodeEvent implements
- AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> {
- //primary fields
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event;
- private InstanceIdentifier<?> iid;
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> {
- // local caches of computed data
- private Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> createdData = null;
- private Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> updatedData = null;
- private Set<InstanceIdentifier<?>> removedPaths = null;
- private Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> originalData;
+ private InstanceIdentifier<?> iid;
+ private DataBroker db;
+ private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event;
+ private Map<InstanceIdentifier<?>, DataObject> createdData = null;
+ private Map<InstanceIdentifier<?>, DataObject> updatedData = null;
+ private Map<InstanceIdentifier<?>, DataObject> originalData = null;
+ private Set<InstanceIdentifier<?>> removedPaths;
- public DataChangesManagedByOvsdbNodeEvent(InstanceIdentifier<?> iid, AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event) {
+ public DataChangesManagedByOvsdbNodeEvent(DataBroker dataBroker, InstanceIdentifier<?> iid,
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event) {
+ this.db = dataBroker;
this.iid = iid;
this.event = event;
}
- private Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> filter(Map<InstanceIdentifier<?>, DataObject> data) {
- Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> result = new HashMap<InstanceIdentifier<?>, OvsdbBridgeAugmentation>();
- for(Entry<InstanceIdentifier<?>, DataObject> created: data.entrySet()) {
- if(created.getValue() != null
- && created.getValue() instanceof OvsdbBridgeAugmentation
- && ((OvsdbBridgeAugmentation)created.getValue()).getManagedBy() != null
- && ((OvsdbBridgeAugmentation)created.getValue()).getManagedBy().getValue() != null
- && ((OvsdbBridgeAugmentation)created.getValue()).getManagedBy().getValue().equals(iid)) {
- result.put(created.getKey(),((OvsdbBridgeAugmentation)created.getValue()));
+ private Map<InstanceIdentifier<?>, DataObject> filter(Map<InstanceIdentifier<?>,
+ DataObject> data) {
+ Map<InstanceIdentifier<?>, DataObject> result
+ = new HashMap<>();
+ for (Entry<InstanceIdentifier<?>, DataObject> entry: data.entrySet()) {
+ if (isManagedBy(entry.getKey())) {
+ result.put(entry.getKey(),entry.getValue());
+ } else {
+ Class<?> type = entry.getKey().getTargetType();
+ if (type.equals(OvsdbNodeAugmentation.class)
+ || type.equals(OvsdbTerminationPointAugmentation.class)
+ || type.equals(Node.class)) {
+ result.put(entry.getKey(), entry.getValue());
+ }
}
}
return result;
}
@Override
- public Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> getCreatedData() {
- if(this.createdData == null) {
+ public Map<InstanceIdentifier<?>, DataObject> getCreatedData() {
+ if (this.createdData == null) {
this.createdData = filter(event.getCreatedData());
}
return this.createdData;
}
@Override
- public Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> getUpdatedData() {
- if(this.updatedData == null) {
+ public Map<InstanceIdentifier<?>, DataObject> getUpdatedData() {
+ if (this.updatedData == null) {
this.updatedData = filter(event.getUpdatedData());
}
return this.updatedData;
@Override
public Set<InstanceIdentifier<?>> getRemovedPaths() {
- if(this.removedPaths != null) {
- this.removedPaths = new HashSet<InstanceIdentifier<?>>();
- for(InstanceIdentifier<?> path: event.getRemovedPaths()) {
- DataObject original = this.event.getOriginalData().get(path);
- if(original != null
- && original instanceof OvsdbBridgeAugmentation
- && ((OvsdbBridgeAugmentation)original).getManagedBy().equals(this.iid)) {
+ if (this.removedPaths == null) {
+ this.removedPaths = new HashSet<>();
+ for (InstanceIdentifier<?> path: event.getRemovedPaths()) {
+ if (isManagedBy(path)) {
this.removedPaths.add(path);
}
}
return this.removedPaths;
}
+ private boolean isManagedBy(InstanceIdentifier<?> bridgeIid) {
+
+ // Did we just create the containing node?
+ InstanceIdentifier<?> managedBy = getManagedByIid(event.getCreatedData() , bridgeIid);
+ if (managedBy != null && managedBy.equals(iid)) {
+ return true;
+ }
+
+ // Did we just update the containing node?
+ managedBy = getManagedByIid(event.getUpdatedData() , bridgeIid);
+ if (managedBy != null && managedBy.equals(iid)) {
+ return true;
+ }
+
+ // Did we have the containing node already (note: we never get here unless we are deleting it)
+ managedBy = getManagedByIid(event.getOriginalData() , bridgeIid);
+ if (managedBy != null && managedBy.equals(iid)) {
+ return true;
+ }
+
+ managedBy = getManagedByIidFromOperDS(bridgeIid);
+ if (managedBy != null && managedBy.equals(iid)) {
+ return true;
+ }
+ return false;
+
+ }
+
+ private InstanceIdentifier<?> getManagedByIidFromOperDS(InstanceIdentifier<?> bridgeIid) {
+ // Get the InstanceIdentifier of the containing node
+ InstanceIdentifier<Node> nodeEntryIid = bridgeIid.firstIdentifierOf(Node.class);
+
+ Optional<?> bridgeNode = SouthboundUtil.readNode(db.newReadWriteTransaction(),nodeEntryIid);
+ if (bridgeNode.isPresent() && bridgeNode.get() instanceof Node) {
+ Node node = (Node)bridgeNode.get();
+ OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
+ if (bridge != null && bridge.getManagedBy() != null) {
+ return bridge.getManagedBy().getValue();
+ }
+ }
+ return null;
+ }
+
+ private InstanceIdentifier<?> getManagedByIid(Map<InstanceIdentifier<?>, DataObject> map,
+ InstanceIdentifier<?> iidToCheck) {
+ // Get the InstanceIdentifier of the containing node
+ InstanceIdentifier<Node> nodeEntryIid = iidToCheck.firstIdentifierOf(Node.class);
+
+ // Look for the Node in the created/updated data
+ DataObject dataObject = null;
+ if (map != null && map.get(nodeEntryIid) != null) {
+ dataObject = map.get(nodeEntryIid);
+ }
+ // If we are contained in a bridge managed by this iid
+ if (dataObject != null && dataObject instanceof Node) {
+ Node node = (Node)dataObject;
+ OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
+ if (bridge != null && bridge.getManagedBy() != null && bridge.getManagedBy().getValue().equals(this.iid)) {
+ return bridge.getManagedBy().getValue();
+ }
+ }
+ return null;
+ }
+
@Override
- public Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> getOriginalData() {
- if(this.originalData == null) {
+ public Map<InstanceIdentifier<?>, DataObject> getOriginalData() {
+ if (this.originalData == null) {
this.originalData = filter(event.getOriginalData());
}
return this.originalData;
}
@Override
- public OvsdbBridgeAugmentation getOriginalSubtree() {
- if(this.event.getOriginalSubtree() instanceof OvsdbBridgeAugmentation) {
- return (OvsdbBridgeAugmentation)this.event.getOriginalSubtree();
- } else {
- return null;
- }
+ public DataObject getOriginalSubtree() {
+ // TODO Auto-generated method stub
+ return event.getOriginalSubtree();
}
@Override
- public OvsdbBridgeAugmentation getUpdatedSubtree() {
- if(this.event.getUpdatedSubtree() instanceof OvsdbBridgeAugmentation) {
- return (OvsdbBridgeAugmentation)this.event.getUpdatedSubtree();
- } else {
- return null;
- }
+ public DataObject getUpdatedSubtree() {
+ // TODO Auto-generated method stub
+ return event.getUpdatedSubtree();
}
+
}
Code Review / ovsdb.git / blobdiff