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