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