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

   1 package org.opendaylight.ovsdb.southbound.ovsdb.transact;
   2
   3 import static org.opendaylight.ovsdb.lib.operations.Operations.op;
   4
   5 import java.util.Map;
   6 import java.util.Set;
   7 import java.util.concurrent.ExecutionException;
   8
   9 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  10 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  11 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  12 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  13 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  14 import org.opendaylight.ovsdb.lib.notation.Mutator;
  15 import org.opendaylight.ovsdb.lib.notation.UUID;
  16 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
  17 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  18 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  19 import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  21 import org.opendaylight.yangtools.yang.binding.DataObject;
  22 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  23 import org.slf4j.Logger;
  24 import org.slf4j.LoggerFactory;
  25
  26 import com.google.common.base.Optional;
  27 import com.google.common.collect.Sets;
  28 import com.google.common.util.concurrent.CheckedFuture;
  29
  30 public class BridgeRemovedCommand implements TransactCommand {
  31     private static final Logger LOG = LoggerFactory.getLogger(BridgeRemovedCommand.class);
  32     private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes;
  33     private DataBroker db;
  34
  35     public BridgeRemovedCommand(DataBroker db, AsyncDataChangeEvent<InstanceIdentifier<?>,
  36             DataObject> changes) {
  37         this.db = db;
  38         this.changes = changes;
  39     }
  40
  41     @Override
  42     public void execute(TransactionBuilder transaction) {
  43         Set<InstanceIdentifier<OvsdbBridgeAugmentation>> removed =
  44                 TransactUtils.extractRemoved(changes,OvsdbBridgeAugmentation.class);
  45         Map<InstanceIdentifier<OvsdbBridgeAugmentation>, OvsdbBridgeAugmentation> originals
  46             = TransactUtils.extractOriginal(changes,OvsdbBridgeAugmentation.class);
  47         for (InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbManagedNodeIid: removed) {
  48             LOG.info("Received request to delete ovsdb node {}",ovsdbManagedNodeIid);
  49             OvsdbBridgeAugmentation original = originals.get(ovsdbManagedNodeIid);
  50             Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Bridge.class,null);
  51             Optional<UUID> bridgeUuidOptional = getBridgeUUID(ovsdbManagedNodeIid);
  52             if (bridgeUuidOptional.isPresent()) {
  53                 UUID bridgeUuid = bridgeUuidOptional.get();
  54                 OpenVSwitch ovs = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(),
  55                         OpenVSwitch.class,null);
  56                 transaction.add(op.delete(bridge.getSchema())
  57                         .where(bridge.getUuidColumn().getSchema().opEqual(bridgeUuid)).build());
  58                 transaction.add(op.comment("Bridge: Deleting " + original.getBridgeName()));
  59                 transaction.add(op.mutate(ovs.getSchema())
  60                         .addMutation(ovs.getBridgesColumn().getSchema(), Mutator.DELETE,
  61                                 Sets.newHashSet(bridgeUuid)));
  62                 transaction.add(op.comment("Open_vSwitch: Mutating " + original.getBridgeName() + " " + bridgeUuid));
  63             } else {
  64                 LOG.warn("Unable to delete bridge {} because it was not found in the operational store, "
  65                         + "and thus we cannot retrieve its UUID", ovsdbManagedNodeIid);
  66             }
  67
  68         }
  69     }
  70
  71     private Optional<UUID> getBridgeUUID(InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbManagedNodeIid) {
  72         Optional<UUID> result = Optional.absent();
  73         ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
  74         CheckedFuture<Optional<OvsdbBridgeAugmentation>, ReadFailedException> future
  75             = transaction.read(LogicalDatastoreType.OPERATIONAL, ovsdbManagedNodeIid);
  76         Optional<OvsdbBridgeAugmentation> optional;
  77         try {
  78             optional = future.get();
  79             if (optional.isPresent()) {
  80                 OvsdbBridgeAugmentation bridge = (OvsdbBridgeAugmentation) optional.get();
  81                 if (bridge != null && bridge.getBridgeUuid() != null) {
  82                     result = Optional.of(new UUID(bridge.getBridgeUuid().getValue()));
  83                 }
  84             }
  85         } catch (InterruptedException e) {
  86             LOG.warn("Unable to retrieve bridge from operational store",e);
  87         } catch (ExecutionException e) {
  88             LOG.warn("Unable to retrieve bridge from operational store",e);
  89         }
  90         transaction.close();
  91         return result;
  92     }
  93
  94 }