opendaylight/md-sal/sal-netconf-connector/src/main/java/org/opendaylight/controller/sal/connect/netconf/sal/NetconfDeviceDatastoreAdapter.java

   1 /*
   2  * Copyright (c) 2014 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.sal.connect.netconf.sal;
   9
  10 import com.google.common.base.Function;
  11 import com.google.common.base.Optional;
  12 import com.google.common.base.Preconditions;
  13 import com.google.common.collect.FluentIterable;
  14 import com.google.common.util.concurrent.CheckedFuture;
  15 import com.google.common.util.concurrent.FutureCallback;
  16 import com.google.common.util.concurrent.Futures;
  17 import com.google.common.util.concurrent.ListenableFuture;
  18
  19 import java.util.Set;
  20 import java.util.concurrent.ExecutionException;
  21
  22 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
  23 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  24 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  27 import org.opendaylight.controller.sal.connect.util.RemoteDeviceId;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodesBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.inventory.rev140108.NetconfNode;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.inventory.rev140108.NetconfNodeBuilder;
  34 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  35 import org.opendaylight.yangtools.yang.common.QName;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 /**
  40  * Asynchronous (Binding-aware) adapter over datastore subtree for netconf device.
  41  *
  42  * All data changes are submitted to an ExecutorService to avoid Thread blocking while sal is waiting for schema.
  43  *
  44  * @deprecated Data is pushed into Topology instead if Inventory model
  45  */
  46 @Deprecated
  47 final class NetconfDeviceDatastoreAdapter implements AutoCloseable {
  48
  49     private static final Logger logger  = LoggerFactory.getLogger(NetconfDeviceDatastoreAdapter.class);
  50
  51     private final RemoteDeviceId id;
  52     private BindingTransactionChain txChain;
  53
  54     NetconfDeviceDatastoreAdapter(final RemoteDeviceId deviceId, final BindingTransactionChain txChain) {
  55         this.id = Preconditions.checkNotNull(deviceId);
  56         this.txChain = Preconditions.checkNotNull(txChain);
  57
  58         initDeviceData();
  59     }
  60
  61     public void updateDeviceState(final boolean up, final Set<QName> capabilities) {
  62         final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node data = buildDataForDeviceState(
  63                 up, capabilities, id);
  64
  65         final ReadWriteTransaction transaction = txChain.newReadWriteTransaction();
  66         logger.trace("{}: Update device state transaction {} merging operational data started.", id, transaction.getIdentifier());
  67         transaction.put(LogicalDatastoreType.OPERATIONAL, id.getBindingPath(), data);
  68         logger.trace("{}: Update device state transaction {} merging operational data ended.", id, transaction.getIdentifier());
  69
  70         commitTransaction(transaction, "update");
  71     }
  72
  73     private void removeDeviceConfigAndState() {
  74         final WriteTransaction transaction = txChain.newWriteOnlyTransaction();
  75         logger.trace("{}: Close device state transaction {} removing all data started.", id, transaction.getIdentifier());
  76         transaction.delete(LogicalDatastoreType.CONFIGURATION, id.getBindingPath());
  77         transaction.delete(LogicalDatastoreType.OPERATIONAL, id.getBindingPath());
  78         logger.trace("{}: Close device state transaction {} removing all data ended.", id, transaction.getIdentifier());
  79
  80         try {
  81             transaction.submit().get();
  82         } catch (InterruptedException | ExecutionException e) {
  83             logger.error("{}: Transaction(close) {} FAILED!", id, transaction.getIdentifier(), e);
  84             throw new IllegalStateException(id + "  Transaction(close) not committed correctly", e);
  85         }
  86     }
  87
  88     private void initDeviceData() {
  89         final WriteTransaction transaction = txChain.newWriteOnlyTransaction();
  90
  91         createNodesListIfNotPresent(transaction);
  92
  93         final InstanceIdentifier<Node> path = id.getBindingPath();
  94         final Node nodeWithId = getNodeWithId(id);
  95
  96         logger.trace("{}: Init device state transaction {} putting if absent operational data started.", id, transaction.getIdentifier());
  97         transaction.put(LogicalDatastoreType.OPERATIONAL, path, nodeWithId);
  98         logger.trace("{}: Init device state transaction {} putting operational data ended.", id, transaction.getIdentifier());
  99
 100         logger.trace("{}: Init device state transaction {} putting if absent config data started.", id, transaction.getIdentifier());
 101         transaction.put(LogicalDatastoreType.CONFIGURATION, path, nodeWithId);
 102         logger.trace("{}: Init device state transaction {} putting config data ended.", id, transaction.getIdentifier());
 103
 104         commitTransaction(transaction, "init");
 105     }
 106
 107     private void createNodesListIfNotPresent(final WriteTransaction writeTx) {
 108         final Nodes nodes = new NodesBuilder().build();
 109         final InstanceIdentifier<Nodes> path = InstanceIdentifier.builder(Nodes.class).build();
 110         logger.trace("{}: Merging {} container to ensure its presence", id, Nodes.QNAME, writeTx.getIdentifier());
 111         writeTx.merge(LogicalDatastoreType.CONFIGURATION, path, nodes);
 112         writeTx.merge(LogicalDatastoreType.OPERATIONAL, path, nodes);
 113     }
 114
 115     private void commitTransaction(final WriteTransaction transaction, final String txType) {
 116         logger.trace("{}: Committing Transaction {}:{}", id, txType, transaction.getIdentifier());
 117         final CheckedFuture<Void, TransactionCommitFailedException> result = transaction.submit();
 118
 119         Futures.addCallback(result, new FutureCallback<Void>() {
 120             @Override
 121             public void onSuccess(final Void result) {
 122                 logger.trace("{}: Transaction({}) {} SUCCESSFUL", id, txType, transaction.getIdentifier());
 123             }
 124
 125             @Override
 126             public void onFailure(final Throwable t) {
 127                 logger.error("{}: Transaction({}) {} FAILED!", id, txType, transaction.getIdentifier(), t);
 128                 throw new IllegalStateException(id + "  Transaction(" + txType + ") not committed correctly", t);
 129             }
 130         });
 131
 132     }
 133
 134     @Override
 135     public void close() throws Exception {
 136         removeDeviceConfigAndState();
 137     }
 138
 139     public static org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node buildDataForDeviceState(
 140             final boolean up, final Set<QName> capabilities, final RemoteDeviceId id) {
 141
 142         final NodeBuilder nodeBuilder = getNodeWithIdBuilder(id);
 143         final NetconfNodeBuilder netconfNodeBuilder = new NetconfNodeBuilder();
 144         netconfNodeBuilder.setConnected(up);
 145         netconfNodeBuilder.setInitialCapability(FluentIterable.from(capabilities)
 146                 .transform(new Function<QName, String>() {
 147                     @Override
 148                     public String apply(final QName input) {
 149                         return input.toString();
 150                     }
 151                 }).toList());
 152         nodeBuilder.addAugmentation(NetconfNode.class, netconfNodeBuilder.build());
 153
 154         return nodeBuilder.build();
 155     }
 156
 157     private static ListenableFuture<Optional<Node>> readNodeData(
 158             final LogicalDatastoreType store,
 159             final ReadWriteTransaction transaction,
 160             final InstanceIdentifier<Node> path) {
 161         return transaction.read(store, path);
 162     }
 163
 164     private static Node getNodeWithId(final RemoteDeviceId id) {
 165         final NodeBuilder nodeBuilder = getNodeWithIdBuilder(id);
 166         return nodeBuilder.build();
 167     }
 168
 169     private static NodeBuilder getNodeWithIdBuilder(final RemoteDeviceId id) {
 170         final NodeBuilder nodeBuilder = new NodeBuilder();
 171         nodeBuilder.setKey(id.getBindingKey());
 172         nodeBuilder.setId(id.getBindingKey().getId());
 173         return nodeBuilder;
 174     }
 175
 176     public void setTxChain(BindingTransactionChain txChain) {
 177         this.txChain = Preconditions.checkNotNull(txChain);
 178     }
 179 }