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

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