southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/DataChangesManagedByOvsdbNodeEvent.java

   1 package org.opendaylight.ovsdb.southbound.ovsdb.transact;
   2
   3 import java.util.HashMap;
   4 import java.util.HashSet;
   5 import java.util.Map;
   6 import java.util.Map.Entry;
   7 import java.util.Set;
   8
   9 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  10 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  11 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  12 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  13 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  14 import org.opendaylight.yangtools.yang.binding.DataObject;
  15 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  16
  17 public class DataChangesManagedByOvsdbNodeEvent implements
  18     AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> {
  19
  20     private InstanceIdentifier<?> iid;
  21     private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event;
  22     private Map<InstanceIdentifier<?>, DataObject> createdData = null;
  23     private Map<InstanceIdentifier<?>, DataObject> updatedData = null;
  24     private Map<InstanceIdentifier<?>, DataObject> originalData = null;
  25     private Set<InstanceIdentifier<?>> removedPaths;
  26
  27     public DataChangesManagedByOvsdbNodeEvent(InstanceIdentifier<?> iid,
  28             AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event) {
  29         this.iid = iid;
  30         this.event = event;
  31     }
  32
  33     private Map<InstanceIdentifier<?>, DataObject> filter(Map<InstanceIdentifier<?>,
  34             DataObject> data) {
  35         Map<InstanceIdentifier<?>, DataObject> result
  36             = new HashMap<InstanceIdentifier<?>, DataObject>();
  37         for (Entry<InstanceIdentifier<?>, DataObject> entry: data.entrySet()) {
  38             if (isManagedBy(entry.getKey())) {
  39                 result.put(entry.getKey(),entry.getValue());
  40             } else {
  41                 Class<?> type = entry.getKey().getTargetType();
  42                 if (type.equals(OvsdbNodeAugmentation.class)
  43                         || type.equals(OvsdbTerminationPointAugmentation.class)
  44                         || type.equals(Node.class)) {
  45                     result.put(entry.getKey(), entry.getValue());
  46                 }
  47             }
  48         }
  49         return result;
  50     }
  51
  52     @Override
  53     public Map<InstanceIdentifier<?>, DataObject> getCreatedData() {
  54         if (this.createdData  == null) {
  55             this.createdData = filter(event.getCreatedData());
  56         }
  57         return this.createdData;
  58     }
  59
  60     @Override
  61     public Map<InstanceIdentifier<?>, DataObject> getUpdatedData() {
  62         if (this.updatedData == null) {
  63             this.updatedData = filter(event.getUpdatedData());
  64         }
  65         return this.updatedData;
  66     }
  67
  68     @Override
  69     public Set<InstanceIdentifier<?>> getRemovedPaths() {
  70         if (this.removedPaths == null) {
  71             this.removedPaths = new HashSet<InstanceIdentifier<?>>();
  72             for (InstanceIdentifier<?> path: event.getRemovedPaths()) {
  73                 if (isManagedBy(path)) {
  74                     this.removedPaths.add(path);
  75                 }
  76             }
  77         }
  78         return this.removedPaths;
  79     }
  80
  81     private boolean isManagedBy(InstanceIdentifier<?> bridgeIid) {
  82
  83         // Did we just create the containing node?
  84         InstanceIdentifier<?> managedBy = getManagedByIid(event.getCreatedData() , bridgeIid);
  85         if (managedBy != null && managedBy.equals(iid)) {
  86             return true;
  87         }
  88
  89         // Did we just update the containing node?
  90         managedBy = getManagedByIid(event.getUpdatedData() , bridgeIid);
  91         if (managedBy != null && managedBy.equals(iid)) {
  92             return true;
  93         }
  94
  95         // Did we have the containing node already (note: we never get here unless we are deleting it)
  96         managedBy = getManagedByIid(event.getOriginalData() , bridgeIid);
  97         if (managedBy != null && managedBy.equals(iid)) {
  98             return true;
  99         }
 100         return false;
 101
 102     }
 103
 104     private InstanceIdentifier<?> getManagedByIid(Map<InstanceIdentifier<?>, DataObject> map,
 105             InstanceIdentifier<?> iidToCheck) {
 106         // Get the InstanceIdentifier of the containing node
 107         InstanceIdentifier<Node> nodeEntryIid = iidToCheck.firstIdentifierOf(Node.class);
 108
 109         // Look for the Node in the created/updated data
 110         DataObject dataObject = null;
 111         if (map != null && map.get(nodeEntryIid) != null) {
 112             dataObject = map.get(nodeEntryIid);
 113         }
 114         // If we are contained in a bridge managed by this iid
 115         if (dataObject != null && dataObject instanceof Node) {
 116             Node node = (Node)dataObject;
 117             OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
 118             if (bridge != null && bridge.getManagedBy() != null && bridge.getManagedBy().getValue().equals(this.iid)) {
 119                 return bridge.getManagedBy().getValue();
 120             }
 121         }
 122         return null;
 123     }
 124
 125     @Override
 126     public Map<InstanceIdentifier<?>, DataObject> getOriginalData() {
 127         if (this.originalData == null) {
 128             this.originalData = filter(event.getOriginalData());
 129         }
 130         return this.originalData;
 131     }
 132
 133     @Override
 134     public DataObject getOriginalSubtree() {
 135         // TODO Auto-generated method stub
 136         return event.getOriginalSubtree();
 137     }
 138
 139     @Override
 140     public DataObject getUpdatedSubtree() {
 141         // TODO Auto-generated method stub
 142         return event.getUpdatedSubtree();
 143     }
 144
 145 }