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