opendaylight/md-sal/inventory-manager/src/main/java/org/opendaylight/controller/md/inventory/manager/NodeChangeCommiter.java

   1 /**
   2  * Copyright (c) 2013 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 package org.opendaylight.controller.md.inventory.manager;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.base.Preconditions;
  12 import com.google.common.util.concurrent.CheckedFuture;
  13 import com.google.common.util.concurrent.FutureCallback;
  14 import com.google.common.util.concurrent.Futures;
  15 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  16 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorUpdated;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableBuilder;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRemoved;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRemoved;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.OpendaylightInventoryListener;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  35 import org.opendaylight.yangtools.yang.binding.DataObject;
  36 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  37 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  38 import org.slf4j.Logger;
  39 import org.slf4j.LoggerFactory;
  40
  41 class NodeChangeCommiter implements OpendaylightInventoryListener {
  42     private static final Logger LOG = LoggerFactory.getLogger(NodeChangeCommiter.class);
  43
  44     private final FlowCapableInventoryProvider manager;
  45
  46     public NodeChangeCommiter(final FlowCapableInventoryProvider manager) {
  47         this.manager = Preconditions.checkNotNull(manager);
  48     }
  49
  50     @Override
  51     public synchronized void onNodeConnectorRemoved(final NodeConnectorRemoved connector) {
  52         LOG.debug("Node connector removed notification received.");
  53         manager.enqueue(new InventoryOperation() {
  54             @Override
  55             public void applyOperation(final ReadWriteTransaction tx) {
  56                 final NodeConnectorRef ref = connector.getNodeConnectorRef();
  57                 LOG.debug("removing node connector {} ", ref.getValue());
  58                 tx.delete(LogicalDatastoreType.OPERATIONAL, ref.getValue());
  59             }
  60         });
  61     }
  62
  63     @Override
  64     public synchronized void onNodeConnectorUpdated(final NodeConnectorUpdated connector) {
  65         LOG.debug("Node connector updated notification received.");
  66         manager.enqueue(new InventoryOperation() {
  67             @Override
  68             public void applyOperation(final ReadWriteTransaction tx) {
  69                 final NodeConnectorRef ref = connector.getNodeConnectorRef();
  70                 final NodeConnectorBuilder data = new NodeConnectorBuilder(connector);
  71                 data.setKey(new NodeConnectorKey(connector.getId()));
  72
  73                 final FlowCapableNodeConnectorUpdated flowConnector = connector
  74                         .getAugmentation(FlowCapableNodeConnectorUpdated.class);
  75                 if (flowConnector != null) {
  76                     final FlowCapableNodeConnector augment = InventoryMapping.toInventoryAugment(flowConnector);
  77                     data.addAugmentation(FlowCapableNodeConnector.class, augment);
  78                 }
  79                 InstanceIdentifier<NodeConnector> value = (InstanceIdentifier<NodeConnector>) ref.getValue();
  80                 LOG.debug("updating node connector : {}.", value);
  81                 NodeConnector build = data.build();
  82                 tx.merge(LogicalDatastoreType.OPERATIONAL, value, build, true);
  83             }
  84         });
  85     }
  86
  87     @Override
  88     public synchronized void onNodeRemoved(final NodeRemoved node) {
  89         LOG.debug("Node removed notification received.");
  90         manager.enqueue(new InventoryOperation() {
  91             @Override
  92             public void applyOperation(final ReadWriteTransaction tx) {
  93                 final NodeRef ref = node.getNodeRef();
  94                 LOG.debug("removing node : {}", ref.getValue());
  95                 tx.delete(LogicalDatastoreType.OPERATIONAL, ref.getValue());
  96             }
  97         });
  98     }
  99
 100     @Override
 101     public synchronized void onNodeUpdated(final NodeUpdated node) {
 102         final FlowCapableNodeUpdated flowNode = node.getAugmentation(FlowCapableNodeUpdated.class);
 103         if (flowNode == null) {
 104             return;
 105         }
 106         LOG.debug("Node updated notification received.");
 107         manager.enqueue(new InventoryOperation() {
 108             @Override
 109             public void applyOperation(ReadWriteTransaction tx) {
 110                 final NodeRef ref = node.getNodeRef();
 111                 @SuppressWarnings("unchecked")
 112                 InstanceIdentifierBuilder<Node> builder = ((InstanceIdentifier<Node>) ref.getValue()).builder();
 113                 InstanceIdentifierBuilder<FlowCapableNode> augmentation = builder.augmentation(FlowCapableNode.class);
 114                 final InstanceIdentifier<FlowCapableNode> path = augmentation.build();
 115                 CheckedFuture readFuture = tx.read(LogicalDatastoreType.OPERATIONAL, path);
 116                 Futures.addCallback(readFuture, new FutureCallback<Optional<? extends DataObject>>() {
 117                     @Override
 118                     public void onSuccess(Optional<? extends DataObject> optional) {
 119                         enqueueWriteNodeDataTx(node, flowNode, path);
 120                         if (!optional.isPresent()) {
 121                             enqueuePutTable0Tx(ref);
 122                         }
 123                     }
 124
 125                     @Override
 126                     public void onFailure(Throwable throwable) {
 127                         LOG.debug(String.format("Can't retrieve node data for node %s. Writing node data with table0.", node));
 128                         enqueueWriteNodeDataTx(node, flowNode, path);
 129                         enqueuePutTable0Tx(ref);
 130                     }
 131                 });
 132             }
 133         });
 134     }
 135
 136     private void enqueueWriteNodeDataTx(final NodeUpdated node, final FlowCapableNodeUpdated flowNode, final InstanceIdentifier<FlowCapableNode> path) {
 137         manager.enqueue(new InventoryOperation() {
 138             @Override
 139             public void applyOperation(final ReadWriteTransaction tx) {
 140                 final FlowCapableNode augment = InventoryMapping.toInventoryAugment(flowNode);
 141                 LOG.debug("updating node :{} ", path);
 142                 tx.merge(LogicalDatastoreType.OPERATIONAL, path, augment, true);
 143             }
 144         });
 145     }
 146
 147     private void enqueuePutTable0Tx(final NodeRef ref) {
 148         manager.enqueue(new InventoryOperation() {
 149             @Override
 150             public void applyOperation(ReadWriteTransaction tx) {
 151                 final TableKey tKey = new TableKey((short) 0);
 152                 final InstanceIdentifier<Table> tableIdentifier =
 153                         ((InstanceIdentifier<Node>) ref.getValue()).augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tKey));
 154                 TableBuilder tableBuilder = new TableBuilder();
 155                 Table table0 = tableBuilder.setId((short) 0).build();
 156                 LOG.debug("writing table :{} ", tableIdentifier);
 157                 tx.put(LogicalDatastoreType.OPERATIONAL, tableIdentifier, table0, true);
 158             }
 159         });
 160     }
 161 }