hwvtepsouthbound/hwvtepsouthbound-impl/src/main/java/org/opendaylight/ovsdb/hwvtepsouthbound/transact/HwvtepOperationalState.java

   1 /*
   2  * Copyright (c) 2015 China Telecom Beijing Research Institute 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.hwvtepsouthbound.transact;
  10
  11 import java.util.Collection;
  12 import java.util.HashMap;
  13 import java.util.Map;
  14 import java.util.Map.Entry;
  15 import java.util.concurrent.ExecutionException;
  16
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  18 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
  19 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
  20 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  21 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepLogicalSwitchAugmentation;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorAugmentation;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalLocatorSetAugmentation;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalPortAugmentation;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
  29 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  30 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  31 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  32 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35 import com.google.common.base.Optional;
  36 import com.google.common.util.concurrent.CheckedFuture;
  37
  38 public class HwvtepOperationalState {
  39     private static final Logger LOG = LoggerFactory.getLogger(HwvtepOperationalState.class);
  40     private Map<InstanceIdentifier<Node>, Node> operationalNodes = new HashMap<>();
  41
  42     public HwvtepOperationalState(DataBroker db, Collection<DataTreeModification<Node>> changes) {
  43         ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
  44         Map<InstanceIdentifier<Node>, Node> nodeCreateOrUpdate =
  45             extractCreatedOrUpdatedOrRemoved(changes, Node.class);
  46             //TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, Node.class);
  47         if (nodeCreateOrUpdate != null) {
  48             for (Entry<InstanceIdentifier<Node>, Node> entry: nodeCreateOrUpdate.entrySet()) {
  49                 CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture =
  50                         transaction.read(LogicalDatastoreType.OPERATIONAL, entry.getKey());
  51                 try {
  52                     Optional<Node> nodeOptional = nodeFuture.get();
  53                     if (nodeOptional.isPresent()) {
  54                         operationalNodes.put(entry.getKey(), nodeOptional.get());
  55                     }
  56                 } catch (InterruptedException | ExecutionException e) {
  57                     LOG.warn("Error reading from datastore",e);
  58                 }
  59             }
  60         }
  61         transaction.close();
  62     }
  63
  64     private Node getCreated(DataObjectModification<Node> mod) {
  65         if((mod.getModificationType() == ModificationType.WRITE)
  66                         && (mod.getDataBefore() == null)){
  67             return mod.getDataAfter();
  68         }
  69         return null;
  70     }
  71
  72     private Node getRemoved(DataObjectModification<Node> mod) {
  73         if(mod.getModificationType() == ModificationType.DELETE){
  74             return mod.getDataBefore();
  75         }
  76         return null;
  77     }
  78
  79     private Node getUpdated(DataObjectModification<Node> mod) {
  80         Node node = null;
  81         switch(mod.getModificationType()) {
  82             case SUBTREE_MODIFIED:
  83                 node = mod.getDataAfter();
  84                 break;
  85             case WRITE:
  86                 if(mod.getDataBefore() !=  null) {
  87                     node = mod.getDataAfter();
  88                 }
  89                 break;
  90             default:
  91                 break;
  92         }
  93         return node;
  94     }
  95
  96     private Node getOriginal(DataObjectModification<Node> mod) {
  97         Node node = null;
  98         switch(mod.getModificationType()) {
  99             case SUBTREE_MODIFIED:
 100                 node = mod.getDataBefore();
 101                 break;
 102             case WRITE:
 103                 if(mod.getDataBefore() !=  null) {
 104                     node = mod.getDataBefore();
 105                 }
 106                 break;
 107             case DELETE:
 108                 node = mod.getDataBefore();
 109                 break;
 110             default:
 111                 break;
 112         }
 113         return node;
 114     }
 115
 116     private Map<InstanceIdentifier<Node>, Node> extractCreatedOrUpdatedOrRemoved(
 117             Collection<DataTreeModification<Node>> changes, Class<Node> class1) {
 118         // TODO Auto-generated method stub
 119         Map<InstanceIdentifier<Node>, Node> result = new HashMap<InstanceIdentifier<Node>, Node>();
 120         for (DataTreeModification<Node> change : changes) {
 121             final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
 122             final DataObjectModification<Node> mod = change.getRootNode();
 123             Node created = getCreated(mod);
 124             result.put(key, created);
 125             Node updated = getUpdated(mod);
 126             result.put(key, updated);
 127             Node deleted = getRemoved(mod);
 128             result.put(key, deleted);
 129         }
 130         return result;
 131     }
 132
 133     public Optional<Node> getGlobalNode(InstanceIdentifier<?> iid) {
 134         InstanceIdentifier<Node> nodeIid = iid.firstIdentifierOf(Node.class);
 135         return Optional.fromNullable(operationalNodes.get(nodeIid));
 136     }
 137
 138     public Optional<HwvtepLogicalSwitchAugmentation> getLogicalSwitchAugmentation(InstanceIdentifier<?> iid) {
 139         Optional<Node> nodeOptional = getGlobalNode(iid);
 140         if (nodeOptional.isPresent()) {
 141             return Optional.fromNullable(nodeOptional.get().getAugmentation(HwvtepLogicalSwitchAugmentation.class));
 142         }
 143         return Optional.absent();
 144     }
 145
 146     public Optional<PhysicalSwitchAugmentation> getPhysicalSwitchAugmentation(InstanceIdentifier<?> iid) {
 147         Optional<Node> nodeOptional = getGlobalNode(iid);
 148         if (nodeOptional.isPresent()) {
 149             return Optional.fromNullable(nodeOptional.get().getAugmentation(PhysicalSwitchAugmentation.class));
 150         }
 151         return Optional.absent();
 152     }
 153
 154     public Optional<HwvtepPhysicalLocatorSetAugmentation> getPhysicalLocatorSetAugmentation(InstanceIdentifier<?> iid) {
 155         Optional<Node> nodeOptional = getGlobalNode(iid);
 156         if (nodeOptional.isPresent()) {
 157             return Optional.fromNullable(nodeOptional.get().getAugmentation(HwvtepPhysicalLocatorSetAugmentation.class));
 158         }
 159         return Optional.absent();
 160     }
 161
 162     public Optional<TerminationPoint> getHwvtepTerminationPoint(InstanceIdentifier<?> iid) {
 163         if (iid != null) {
 164             Optional<Node> nodeOptional = getGlobalNode(iid);
 165             if (nodeOptional.isPresent() && nodeOptional.get().getTerminationPoint() != null) {
 166                 TerminationPointKey key = iid.firstKeyOf(TerminationPoint.class, TerminationPointKey.class);
 167                 if (key != null) {
 168                     for (TerminationPoint tp:nodeOptional.get().getTerminationPoint()) {
 169                         if (tp.getKey().equals(key)) {
 170                             return Optional.of(tp);
 171                         }
 172                     }
 173                 }
 174             }
 175         }
 176         return Optional.absent();
 177     }
 178
 179     public Optional<HwvtepPhysicalLocatorAugmentation> getPhysicalLocatorAugmentation(InstanceIdentifier<?> iid) {
 180         Optional<TerminationPoint> nodeOptional = getHwvtepTerminationPoint(iid);
 181         if (nodeOptional.isPresent()) {
 182             return Optional.fromNullable(nodeOptional.get().getAugmentation(HwvtepPhysicalLocatorAugmentation.class));
 183         }
 184         return Optional.absent();
 185     }
 186
 187     public Optional<HwvtepPhysicalPortAugmentation> getPhysycalPortAugmentation(InstanceIdentifier<?> iid) {
 188         Optional<TerminationPoint> tpOptional = getHwvtepTerminationPoint(iid);
 189         if (tpOptional.isPresent()) {
 190             return Optional.fromNullable(tpOptional.get().getAugmentation(HwvtepPhysicalPortAugmentation.class));
 191         }
 192         return Optional.absent();
 193     }
 194 }