netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOps.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.netconf.sal.connect.netconf.util;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static java.util.Objects.requireNonNull;
  12 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.COMMIT_RPC_CONTENT;
  13 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.EDIT_CONTENT_NODEID;
  14 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_CANDIDATE_QNAME;
  15 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_COMMIT_QNAME;
  16 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_COPY_CONFIG_NODEID;
  17 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_COPY_CONFIG_QNAME;
  18 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_DEFAULT_OPERATION_NODEID;
  19 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_DISCARD_CHANGES_QNAME;
  20 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_EDIT_CONFIG_NODEID;
  21 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_EDIT_CONFIG_QNAME;
  22 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_ERROR_OPTION_NODEID;
  23 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_CONFIG_NODEID;
  24 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_CONFIG_QNAME;
  25 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_NODEID;
  26 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_QNAME;
  27 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_LOCK_NODEID;
  28 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_LOCK_QNAME;
  29 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_RUNNING_QNAME;
  30 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_SOURCE_NODEID;
  31 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_TARGET_NODEID;
  32 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_UNLOCK_NODEID;
  33 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_UNLOCK_QNAME;
  34 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_VALIDATE_NODEID;
  35 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_VALIDATE_QNAME;
  36 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.ROLLBACK_ON_ERROR_OPTION;
  37 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toFilterStructure;
  38 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toId;
  39
  40 import com.google.common.util.concurrent.FutureCallback;
  41 import com.google.common.util.concurrent.Futures;
  42 import com.google.common.util.concurrent.ListenableFuture;
  43 import com.google.common.util.concurrent.MoreExecutors;
  44 import java.util.Locale;
  45 import java.util.Optional;
  46 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
  47 import org.opendaylight.mdsal.dom.api.DOMRpcService;
  48 import org.opendaylight.netconf.api.ModifyAction;
  49 import org.opendaylight.netconf.sal.connect.netconf.sal.KeepaliveSalFacade.KeepaliveDOMRpcService;
  50 import org.opendaylight.netconf.sal.connect.netconf.sal.SchemalessNetconfDeviceRpc;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.copy.config.input.target.ConfigTarget;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.get.config.input.source.ConfigSource;
  53 import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
  54 import org.opendaylight.yangtools.yang.common.Empty;
  55 import org.opendaylight.yangtools.yang.common.QName;
  56 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  57 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  58 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
  59 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  60 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
  61 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  62 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  63 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  64 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
  65
  66 /**
  67  * Provides base operations for netconf e.g. get, get-config, edit-config, (un)lock, commit etc.
  68  * According to RFC-6241
  69  */
  70 public final class NetconfBaseOps {
  71     private static final NodeIdentifier CONFIG_SOURCE_NODEID = NodeIdentifier.create(ConfigSource.QNAME);
  72     private static final NodeIdentifier CONFIG_TARGET_NODEID = NodeIdentifier.create(ConfigTarget.QNAME);
  73
  74     private final DOMRpcService rpc;
  75     private final MountPointContext mountContext;
  76     private final RpcStructureTransformer transformer;
  77
  78     public NetconfBaseOps(final DOMRpcService rpc, final MountPointContext mountContext) {
  79         this.rpc = rpc;
  80         this.mountContext = mountContext;
  81
  82         if (rpc instanceof KeepaliveDOMRpcService
  83                 && ((KeepaliveDOMRpcService) rpc).getDeviceRpc() instanceof SchemalessNetconfDeviceRpc) {
  84             this.transformer = new SchemalessRpcStructureTransformer();
  85         } else {
  86             this.transformer = new NetconfRpcStructureTransformer(mountContext);
  87         }
  88     }
  89
  90     public ListenableFuture<? extends DOMRpcResult> lock(final FutureCallback<DOMRpcResult> callback,
  91             final QName datastore) {
  92         requireNonNull(callback);
  93         requireNonNull(datastore);
  94
  95         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_QNAME,
  96                 getLockContent(datastore));
  97         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
  98         return future;
  99     }
 100
 101     public ListenableFuture<? extends DOMRpcResult> lockCandidate(final FutureCallback<DOMRpcResult> callback) {
 102         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_QNAME,
 103             getLockContent(NETCONF_CANDIDATE_QNAME));
 104         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 105         return future;
 106     }
 107
 108     public ListenableFuture<? extends DOMRpcResult> lockRunning(final FutureCallback<DOMRpcResult> callback) {
 109         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_QNAME,
 110             getLockContent(NETCONF_RUNNING_QNAME));
 111         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 112         return future;
 113     }
 114
 115     public ListenableFuture<? extends DOMRpcResult> unlock(final FutureCallback<DOMRpcResult> callback,
 116             final QName datastore) {
 117         requireNonNull(callback);
 118         requireNonNull(datastore);
 119
 120         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_QNAME,
 121                 getUnLockContent(datastore));
 122         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 123         return future;
 124     }
 125
 126     public ListenableFuture<? extends DOMRpcResult> unlockRunning(final FutureCallback<DOMRpcResult> callback) {
 127         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_QNAME,
 128             getUnLockContent(NETCONF_RUNNING_QNAME));
 129         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 130         return future;
 131     }
 132
 133     public ListenableFuture<? extends DOMRpcResult> unlockCandidate(final FutureCallback<DOMRpcResult> callback) {
 134         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_QNAME,
 135             getUnLockContent(NETCONF_CANDIDATE_QNAME));
 136         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 137         return future;
 138     }
 139
 140     public ListenableFuture<? extends DOMRpcResult> discardChanges(final FutureCallback<DOMRpcResult> callback) {
 141         requireNonNull(callback);
 142
 143         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_DISCARD_CHANGES_QNAME, null);
 144         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 145         return future;
 146     }
 147
 148     public ListenableFuture<? extends DOMRpcResult> commit(final FutureCallback<DOMRpcResult> callback) {
 149         requireNonNull(callback);
 150
 151         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_COMMIT_QNAME, COMMIT_RPC_CONTENT);
 152         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 153         return future;
 154     }
 155
 156     public ListenableFuture<? extends DOMRpcResult> validate(final FutureCallback<DOMRpcResult> callback,
 157             final QName datastore) {
 158         requireNonNull(callback);
 159
 160         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_VALIDATE_QNAME,
 161             getValidateContent(requireNonNull(datastore)));
 162         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 163         return future;
 164     }
 165
 166     public ListenableFuture<? extends DOMRpcResult> validateCandidate(final FutureCallback<DOMRpcResult> callback) {
 167         return validate(callback, NETCONF_CANDIDATE_QNAME);
 168     }
 169
 170     public ListenableFuture<? extends DOMRpcResult> validateRunning(final FutureCallback<DOMRpcResult> callback) {
 171         return validate(callback, NETCONF_RUNNING_QNAME);
 172     }
 173
 174     public ListenableFuture<? extends DOMRpcResult> copyConfig(final FutureCallback<DOMRpcResult> callback,
 175                                                                final QName source, final QName target) {
 176         requireNonNull(callback);
 177
 178         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_COPY_CONFIG_QNAME,
 179             getCopyConfigContent(requireNonNull(source), requireNonNull(target)));
 180         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 181         return future;
 182     }
 183
 184     public ListenableFuture<? extends DOMRpcResult> copyRunningToCandidate(
 185             final FutureCallback<DOMRpcResult> callback) {
 186         return copyConfig(callback, NETCONF_RUNNING_QNAME, NETCONF_CANDIDATE_QNAME);
 187     }
 188
 189     public ListenableFuture<? extends DOMRpcResult> getConfig(final FutureCallback<DOMRpcResult> callback,
 190                                                               final QName datastore,
 191                                                               final Optional<YangInstanceIdentifier> filterPath) {
 192         requireNonNull(callback);
 193         requireNonNull(datastore);
 194
 195         final ListenableFuture<? extends DOMRpcResult> future;
 196         if (isFilterPresent(filterPath)) {
 197             final DataContainerChild<?, ?> node = transformer.toFilterStructure(filterPath.get());
 198             future = rpc.invokeRpc(NETCONF_GET_CONFIG_QNAME,
 199                 NetconfMessageTransformUtil.wrap(NETCONF_GET_CONFIG_NODEID, getSourceNode(datastore), node));
 200         } else {
 201             future = rpc.invokeRpc(NETCONF_GET_CONFIG_QNAME,
 202                 NetconfMessageTransformUtil.wrap(NETCONF_GET_CONFIG_NODEID, getSourceNode(datastore)));
 203         }
 204
 205         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 206         return future;
 207     }
 208
 209     public ListenableFuture<Optional<NormalizedNode<?, ?>>> getConfigRunningData(
 210             final FutureCallback<DOMRpcResult> callback, final Optional<YangInstanceIdentifier> filterPath) {
 211         return extractData(filterPath, getConfigRunning(callback, filterPath));
 212     }
 213
 214     public ListenableFuture<Optional<NormalizedNode<?, ?>>> getData(final FutureCallback<DOMRpcResult> callback,
 215                                                                     final Optional<YangInstanceIdentifier> filterPath) {
 216         return extractData(filterPath, get(callback, filterPath));
 217     }
 218
 219     private ListenableFuture<Optional<NormalizedNode<?, ?>>> extractData(
 220             final Optional<YangInstanceIdentifier> path, final ListenableFuture<? extends DOMRpcResult> configRunning) {
 221         return Futures.transform(configRunning, result -> {
 222             checkArgument(result.getErrors().isEmpty(), "Unable to read data: %s, errors: %s", path,
 223                 result.getErrors());
 224             final DataContainerChild<?, ?> dataNode = ((ContainerNode) result.getResult())
 225                     .getChild(NetconfMessageTransformUtil.NETCONF_DATA_NODEID).get();
 226             return transformer.selectFromDataStructure(dataNode, path.get());
 227         }, MoreExecutors.directExecutor());
 228     }
 229
 230     public ListenableFuture<? extends DOMRpcResult> getConfigRunning(final FutureCallback<DOMRpcResult> callback,
 231             final Optional<YangInstanceIdentifier> filterPath) {
 232         return getConfig(callback, NETCONF_RUNNING_QNAME, filterPath);
 233     }
 234
 235     public ListenableFuture<? extends DOMRpcResult> getConfigCandidate(final FutureCallback<DOMRpcResult> callback,
 236             final Optional<YangInstanceIdentifier> filterPath) {
 237         return getConfig(callback, NETCONF_CANDIDATE_QNAME, filterPath);
 238     }
 239
 240     public ListenableFuture<? extends DOMRpcResult> get(final FutureCallback<DOMRpcResult> callback,
 241                                                         final Optional<YangInstanceIdentifier> filterPath) {
 242         requireNonNull(callback);
 243
 244         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_GET_QNAME,
 245                 isFilterPresent(filterPath)
 246                     ? NetconfMessageTransformUtil.wrap(NETCONF_GET_NODEID,
 247                         toFilterStructure(filterPath.get(), mountContext.getEffectiveModelContext()))
 248                     : NetconfMessageTransformUtil.GET_RPC_CONTENT);
 249         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 250         return future;
 251     }
 252
 253     private static boolean isFilterPresent(final Optional<YangInstanceIdentifier> filterPath) {
 254         return filterPath.isPresent() && !filterPath.get().isEmpty();
 255     }
 256
 257     public ListenableFuture<? extends DOMRpcResult> editConfigCandidate(
 258             final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild<?, ?> editStructure,
 259             final ModifyAction modifyAction, final boolean rollback) {
 260         return editConfig(callback, NETCONF_CANDIDATE_QNAME, editStructure, Optional.of(modifyAction), rollback);
 261     }
 262
 263     public ListenableFuture<? extends DOMRpcResult> editConfigCandidate(
 264             final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild<?, ?> editStructure,
 265             final boolean rollback) {
 266         return editConfig(callback, NETCONF_CANDIDATE_QNAME, editStructure, Optional.empty(), rollback);
 267     }
 268
 269     public ListenableFuture<? extends DOMRpcResult> editConfigRunning(
 270             final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild<?, ?> editStructure,
 271             final ModifyAction modifyAction, final boolean rollback) {
 272         return editConfig(callback, NETCONF_RUNNING_QNAME, editStructure, Optional.of(modifyAction), rollback);
 273     }
 274
 275     public ListenableFuture<? extends DOMRpcResult> editConfigRunning(
 276             final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild<?, ?> editStructure,
 277             final boolean rollback) {
 278         return editConfig(callback, NETCONF_RUNNING_QNAME, editStructure, Optional.empty(), rollback);
 279     }
 280
 281     public ListenableFuture<? extends DOMRpcResult> editConfig(
 282             final FutureCallback<? super DOMRpcResult> callback, final QName datastore,
 283             final DataContainerChild<?, ?> editStructure, final Optional<ModifyAction> modifyAction,
 284             final boolean rollback) {
 285         requireNonNull(callback);
 286
 287         final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_EDIT_CONFIG_QNAME,
 288                 getEditConfigContent(requireNonNull(datastore), requireNonNull(editStructure), modifyAction, rollback));
 289
 290         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
 291         return future;
 292     }
 293
 294     public ChoiceNode createEditConfigStrcture(final Optional<NormalizedNode<?, ?>> lastChild,
 295                                                final Optional<ModifyAction> operation,
 296                                                final YangInstanceIdentifier dataPath) {
 297         return Builders.choiceBuilder()
 298                 .withNodeIdentifier(EDIT_CONTENT_NODEID)
 299                 .withChild(transformer.createEditConfigStructure(lastChild, dataPath, operation))
 300                 .build();
 301     }
 302
 303     private static ContainerNode getEditConfigContent(
 304             final QName datastore, final DataContainerChild<?, ?> editStructure,
 305             final Optional<ModifyAction> defaultOperation, final boolean rollback) {
 306         final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> editBuilder =
 307                 Builders.containerBuilder().withNodeIdentifier(NETCONF_EDIT_CONFIG_NODEID);
 308
 309         // Target
 310         editBuilder.withChild(getTargetNode(datastore));
 311
 312         // Default operation
 313         if (defaultOperation.isPresent()) {
 314             final String opString = defaultOperation.get().name().toLowerCase(Locale.ROOT);
 315             editBuilder.withChild(Builders.leafBuilder().withNodeIdentifier(NETCONF_DEFAULT_OPERATION_NODEID)
 316                     .withValue(opString).build());
 317         }
 318
 319         // Error option
 320         if (rollback) {
 321             editBuilder.withChild(Builders.leafBuilder().withNodeIdentifier(NETCONF_ERROR_OPTION_NODEID)
 322                     .withValue(ROLLBACK_ON_ERROR_OPTION).build());
 323         }
 324
 325         // Edit content
 326         editBuilder.withChild(editStructure);
 327         return editBuilder.build();
 328     }
 329
 330     public static ContainerNode getSourceNode(final QName datastore) {
 331         return Builders.containerBuilder()
 332                 .withNodeIdentifier(NETCONF_SOURCE_NODEID)
 333                 .withChild(Builders.choiceBuilder()
 334                     .withNodeIdentifier(CONFIG_SOURCE_NODEID)
 335                     .withChild(ImmutableNodes.leafNode(datastore, Empty.getInstance()))
 336                     .build())
 337                 .build();
 338     }
 339
 340     public static ContainerNode getLockContent(final QName datastore) {
 341         return Builders.containerBuilder().withNodeIdentifier(NETCONF_LOCK_NODEID)
 342                 .withChild(getTargetNode(datastore)).build();
 343     }
 344
 345     public static ContainerNode getTargetNode(final QName datastore) {
 346         return Builders.containerBuilder().withNodeIdentifier(NETCONF_TARGET_NODEID)
 347                 .withChild(Builders.choiceBuilder().withNodeIdentifier(CONFIG_TARGET_NODEID).withChild(
 348                     Builders.leafBuilder().withNodeIdentifier(toId(datastore)).withValue(Empty.getInstance()).build())
 349                     .build()).build();
 350     }
 351
 352     public static ContainerNode getCopyConfigContent(final QName source, final QName target) {
 353         return Builders.containerBuilder().withNodeIdentifier(NETCONF_COPY_CONFIG_NODEID)
 354                 .withChild(getTargetNode(target)).withChild(getSourceNode(source)).build();
 355     }
 356
 357     public static ContainerNode getValidateContent(final QName source) {
 358         return Builders.containerBuilder().withNodeIdentifier(NETCONF_VALIDATE_NODEID)
 359                 .withChild(getSourceNode(source)).build();
 360     }
 361
 362     public static ContainerNode getUnLockContent(final QName datastore) {
 363         return Builders.containerBuilder().withNodeIdentifier(NETCONF_UNLOCK_NODEID)
 364                 .withChild(getTargetNode(datastore)).build();
 365     }
 366
 367 }