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