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