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