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

   1 /*
   2  * Copyright (c) 2015 Brocade Communications 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 package org.opendaylight.ovsdb.southbound.ovsdb.transact;
   9
  10 import static org.opendaylight.ovsdb.lib.operations.Operations.op;
  11
  12 import java.util.Map;
  13 import java.util.Set;
  14 import java.util.concurrent.ExecutionException;
  15
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  18 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  19 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  20 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  21 import org.opendaylight.ovsdb.lib.notation.Mutator;
  22 import org.opendaylight.ovsdb.lib.notation.UUID;
  23 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
  24 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  25 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  26 import org.opendaylight.ovsdb.schema.openvswitch.Port;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  29 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  30 import org.opendaylight.yangtools.yang.binding.DataObject;
  31 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 import com.google.common.base.Optional;
  36 import com.google.common.collect.Sets;
  37 import com.google.common.util.concurrent.CheckedFuture;
  38
  39 /**
  40  * @author avishnoi@brocade.com (Anil Vishnoi)
  41  *
  42  */
  43 public class TerminationPointDeleteCommand implements TransactCommand {
  44     private static final Logger LOG = LoggerFactory.getLogger(TerminationPointDeleteCommand.class);
  45     private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes;
  46     private DataBroker db;
  47
  48     public TerminationPointDeleteCommand(DataBroker db, AsyncDataChangeEvent<InstanceIdentifier<?>,
  49             DataObject> changes) {
  50         this.db = db;
  51         this.changes = changes;
  52     }
  53
  54     @Override
  55     public void execute(TransactionBuilder transaction) {
  56         Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation> originals
  57             = TransactUtils.extractOriginal(changes,OvsdbTerminationPointAugmentation.class);
  58         Set<InstanceIdentifier<OvsdbTerminationPointAugmentation>> removedTps
  59             = TransactUtils.extractRemoved(changes, OvsdbTerminationPointAugmentation.class);
  60         for (InstanceIdentifier<OvsdbTerminationPointAugmentation> removedTpIid: removedTps) {
  61             LOG.info("Received request to delete termination point {}",removedTpIid);
  62
  63             OvsdbTerminationPointAugmentation original = originals.get(removedTpIid);
  64             Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class,null);
  65             Optional<UUID> terminationPointUuidOptional = getTerminationPointUUID(removedTpIid);
  66
  67             if (terminationPointUuidOptional.isPresent()) {
  68                 UUID portUuid = terminationPointUuidOptional.get();
  69                 Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(),
  70                         Bridge.class,null);
  71                 Optional<String> bridgeName = getBridgeName(removedTpIid);
  72
  73                 transaction.add(op.delete(port.getSchema())
  74                         .where(port.getUuidColumn().getSchema().opEqual(portUuid)).build());
  75                 transaction.add(op.comment("Port: Deleting " + original.getName()
  76                         + " attached to " + bridgeName));
  77
  78                 transaction.add(op.mutate(bridge.getSchema())
  79                         .addMutation(bridge.getPortsColumn().getSchema(),
  80                                 Mutator.DELETE, Sets.newHashSet(portUuid))
  81                         .where(bridge.getNameColumn().getSchema().opEqual(bridgeName.get())).build());
  82
  83                 transaction.add(op.comment("Bridge: Mutating " + bridgeName.get()
  84                         + " to remove port " + portUuid));
  85             } else {
  86                 LOG.warn("Unable to delete port {} because it was not found in the operational store, "
  87                         + "and thus we cannot retrieve its UUID", terminationPointUuidOptional.get());
  88             }
  89         }
  90     }
  91
  92     private Optional<UUID> getTerminationPointUUID(InstanceIdentifier<OvsdbTerminationPointAugmentation> iid) {
  93
  94         Optional<UUID> result = Optional.absent();
  95         ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
  96         CheckedFuture<Optional<OvsdbTerminationPointAugmentation>, ReadFailedException> future
  97             = transaction.read(LogicalDatastoreType.OPERATIONAL, iid);
  98         Optional<OvsdbTerminationPointAugmentation> optional;
  99         try {
 100             optional = future.get();
 101             if (optional.isPresent()) {
 102                 OvsdbTerminationPointAugmentation terminationPoint
 103                     = (OvsdbTerminationPointAugmentation) optional.get();
 104                 if (terminationPoint != null && terminationPoint.getPortUuid() != null) {
 105                     result = Optional.of(new UUID(terminationPoint.getPortUuid().getValue()));
 106                 }
 107             }
 108         } catch (InterruptedException e) {
 109             LOG.warn("Unable to retrieve termination point from operational store",e);
 110         } catch (ExecutionException e) {
 111             LOG.warn("Unable to retrieve termination point from operational store",e);
 112         }
 113         transaction.close();
 114         return result;
 115     }
 116
 117     private Optional<String> getBridgeName(InstanceIdentifier<OvsdbTerminationPointAugmentation> iid) {
 118
 119         Optional<String> result = Optional.absent();
 120         ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
 121         InstanceIdentifier<Node> tpOvsdbManagedNodeIid = iid.firstIdentifierOf(Node.class);
 122         CheckedFuture<Optional<Node>, ReadFailedException> future
 123             = transaction.read(LogicalDatastoreType.OPERATIONAL, tpOvsdbManagedNodeIid);
 124         Optional<Node> optional;
 125         try {
 126             optional = future.get();
 127             if (optional.isPresent()) {
 128                 OvsdbBridgeAugmentation bridge = optional.get().getAugmentation(OvsdbBridgeAugmentation.class);
 129                 if (bridge != null && bridge.getBridgeName() != null) {
 130                     result = Optional.of(bridge.getBridgeName().getValue());
 131                 }
 132             }
 133         } catch (InterruptedException e) {
 134             LOG.warn("Unable to retrieve bridge from operational store",e);
 135         } catch (ExecutionException e) {
 136             LOG.warn("Unable to retrieve bridge from operational store",e);
 137         }
 138         transaction.close();
 139         return result;
 140     }
 141 }