2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.netconf.sal.connect.netconf.util;
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.GET_RPC_CONTENT;
15 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_CANDIDATE_QNAME;
16 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_COMMIT_QNAME;
17 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_COPY_CONFIG_NODEID;
18 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_COPY_CONFIG_QNAME;
19 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_DEFAULT_OPERATION_NODEID;
20 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_DISCARD_CHANGES_QNAME;
21 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_EDIT_CONFIG_NODEID;
22 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_EDIT_CONFIG_QNAME;
23 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_ERROR_OPTION_NODEID;
24 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_CONFIG_NODEID;
25 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_CONFIG_QNAME;
26 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_NODEID;
27 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_GET_QNAME;
28 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_LOCK_NODEID;
29 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_LOCK_QNAME;
30 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_RUNNING_QNAME;
31 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_SOURCE_NODEID;
32 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_TARGET_NODEID;
33 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_UNLOCK_NODEID;
34 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_UNLOCK_QNAME;
35 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_VALIDATE_NODEID;
36 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_VALIDATE_QNAME;
37 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.ROLLBACK_ON_ERROR_OPTION;
38 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toFilterStructure;
39 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toId;
41 import com.google.common.collect.Iterables;
42 import com.google.common.util.concurrent.FutureCallback;
43 import com.google.common.util.concurrent.Futures;
44 import com.google.common.util.concurrent.ListenableFuture;
45 import com.google.common.util.concurrent.MoreExecutors;
46 import java.util.AbstractMap.SimpleEntry;
47 import java.util.Collections;
48 import java.util.List;
49 import java.util.Locale;
51 import java.util.Optional;
52 import java.util.stream.Collectors;
53 import org.eclipse.jdt.annotation.NonNull;
54 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
55 import org.opendaylight.mdsal.dom.api.DOMRpcService;
56 import org.opendaylight.netconf.api.ModifyAction;
57 import org.opendaylight.netconf.sal.connect.netconf.sal.KeepaliveSalFacade.KeepaliveDOMRpcService;
58 import org.opendaylight.netconf.sal.connect.netconf.sal.SchemalessNetconfDeviceRpc;
59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.copy.config.input.target.ConfigTarget;
60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.get.config.input.source.ConfigSource;
61 import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
62 import org.opendaylight.yangtools.yang.common.Empty;
63 import org.opendaylight.yangtools.yang.common.QName;
64 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
65 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
66 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
67 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
68 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
69 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
70 import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
71 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
72 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
75 * Provides base operations for netconf e.g. get, get-config, edit-config, (un)lock, commit etc.
76 * According to RFC-6241
78 public final class NetconfBaseOps {
79 private static final NodeIdentifier CONFIG_SOURCE_NODEID = NodeIdentifier.create(ConfigSource.QNAME);
80 private static final NodeIdentifier CONFIG_TARGET_NODEID = NodeIdentifier.create(ConfigTarget.QNAME);
82 private final DOMRpcService rpc;
83 private final MountPointContext mountContext;
84 private final RpcStructureTransformer transformer;
86 public NetconfBaseOps(final DOMRpcService rpc, final MountPointContext mountContext) {
88 this.mountContext = mountContext;
90 if (rpc instanceof KeepaliveDOMRpcService
91 && ((KeepaliveDOMRpcService) rpc).getDeviceRpc() instanceof SchemalessNetconfDeviceRpc) {
92 this.transformer = new SchemalessRpcStructureTransformer();
94 this.transformer = new NetconfRpcStructureTransformer(mountContext);
98 public ListenableFuture<? extends DOMRpcResult> lock(final FutureCallback<DOMRpcResult> callback,
99 final QName datastore) {
100 requireNonNull(callback);
101 requireNonNull(datastore);
103 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_QNAME,
104 getLockContent(datastore));
105 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
109 public ListenableFuture<? extends DOMRpcResult> lockCandidate(final FutureCallback<DOMRpcResult> callback) {
110 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_QNAME,
111 getLockContent(NETCONF_CANDIDATE_QNAME));
112 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
116 public ListenableFuture<? extends DOMRpcResult> lockRunning(final FutureCallback<DOMRpcResult> callback) {
117 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_QNAME,
118 getLockContent(NETCONF_RUNNING_QNAME));
119 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
123 public ListenableFuture<? extends DOMRpcResult> unlock(final FutureCallback<DOMRpcResult> callback,
124 final QName datastore) {
125 requireNonNull(callback);
126 requireNonNull(datastore);
128 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_QNAME,
129 getUnLockContent(datastore));
130 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
134 public ListenableFuture<? extends DOMRpcResult> unlockRunning(final FutureCallback<DOMRpcResult> callback) {
135 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_QNAME,
136 getUnLockContent(NETCONF_RUNNING_QNAME));
137 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
141 public ListenableFuture<? extends DOMRpcResult> unlockCandidate(final FutureCallback<DOMRpcResult> callback) {
142 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_QNAME,
143 getUnLockContent(NETCONF_CANDIDATE_QNAME));
144 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
148 public ListenableFuture<? extends DOMRpcResult> discardChanges(final FutureCallback<DOMRpcResult> callback) {
149 requireNonNull(callback);
151 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_DISCARD_CHANGES_QNAME, null);
152 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
156 public ListenableFuture<? extends DOMRpcResult> commit(final FutureCallback<DOMRpcResult> callback) {
157 requireNonNull(callback);
159 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_COMMIT_QNAME, COMMIT_RPC_CONTENT);
160 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
164 public ListenableFuture<? extends DOMRpcResult> validate(final FutureCallback<DOMRpcResult> callback,
165 final QName datastore) {
166 requireNonNull(callback);
168 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_VALIDATE_QNAME,
169 getValidateContent(requireNonNull(datastore)));
170 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
174 public ListenableFuture<? extends DOMRpcResult> validateCandidate(final FutureCallback<DOMRpcResult> callback) {
175 return validate(callback, NETCONF_CANDIDATE_QNAME);
178 public ListenableFuture<? extends DOMRpcResult> validateRunning(final FutureCallback<DOMRpcResult> callback) {
179 return validate(callback, NETCONF_RUNNING_QNAME);
182 public ListenableFuture<? extends DOMRpcResult> copyConfig(final FutureCallback<DOMRpcResult> callback,
183 final QName source, final QName target) {
184 requireNonNull(callback);
186 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_COPY_CONFIG_QNAME,
187 getCopyConfigContent(requireNonNull(source), requireNonNull(target)));
188 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
192 public ListenableFuture<? extends DOMRpcResult> copyRunningToCandidate(
193 final FutureCallback<DOMRpcResult> callback) {
194 return copyConfig(callback, NETCONF_RUNNING_QNAME, NETCONF_CANDIDATE_QNAME);
197 public ListenableFuture<? extends DOMRpcResult> getConfig(final FutureCallback<DOMRpcResult> callback,
198 final QName datastore,
199 final Optional<YangInstanceIdentifier> filterPath) {
200 requireNonNull(callback);
201 requireNonNull(datastore);
203 final ListenableFuture<? extends DOMRpcResult> future;
204 if (isFilterPresent(filterPath)) {
205 final DataContainerChild node = transformer.toFilterStructure(filterPath.get());
206 future = rpc.invokeRpc(NETCONF_GET_CONFIG_QNAME,
207 NetconfMessageTransformUtil.wrap(NETCONF_GET_CONFIG_NODEID, getSourceNode(datastore), node));
209 future = rpc.invokeRpc(NETCONF_GET_CONFIG_QNAME,
210 NetconfMessageTransformUtil.wrap(NETCONF_GET_CONFIG_NODEID, getSourceNode(datastore)));
213 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
217 private ListenableFuture<? extends DOMRpcResult> getConfig(final FutureCallback<DOMRpcResult> callback,
218 final QName datastore, final Optional<YangInstanceIdentifier> filterPath,
219 final List<YangInstanceIdentifier> fields) {
220 requireNonNull(callback);
221 requireNonNull(datastore);
223 final NormalizedNode rpcInput;
224 if (isFilterPresent(filterPath)) {
225 final DataContainerChild node = transformer.toFilterStructure(
226 Collections.singletonList(FieldsFilter.of(filterPath.get(), fields)));
227 rpcInput = NetconfMessageTransformUtil.wrap(NETCONF_GET_CONFIG_NODEID, getSourceNode(datastore), node);
228 } else if (containsEmptyPath(fields)) {
229 rpcInput = NetconfMessageTransformUtil.wrap(NETCONF_GET_CONFIG_NODEID, getSourceNode(datastore));
231 final DataContainerChild subtreeFilter = getSubtreeFilterFromRootFields(fields);
232 rpcInput = NetconfMessageTransformUtil.wrap(NETCONF_GET_CONFIG_NODEID,
233 getSourceNode(datastore), subtreeFilter);
235 final ListenableFuture<? extends DOMRpcResult> response = rpc.invokeRpc(NETCONF_GET_CONFIG_QNAME, rpcInput);
236 Futures.addCallback(response, callback, MoreExecutors.directExecutor());
241 * Calling GET-CONFIG RPC with subtree filter that is specified by {@link YangInstanceIdentifier}.
243 * @param callback RPC response callback
244 * @param filterPath path to requested data
245 * @return asynchronous completion token with read {@link NormalizedNode} wrapped in {@link Optional} instance
247 public ListenableFuture<Optional<NormalizedNode>> getConfigRunningData(final FutureCallback<DOMRpcResult> callback,
248 final Optional<YangInstanceIdentifier> filterPath) {
249 return extractData(filterPath, getConfigRunning(callback, filterPath));
253 * Calling GET-CONFIG RPC with subtree filter tha tis specified by parent {@link YangInstanceIdentifier} and list
254 * of specific fields that caller would like to read. Field paths are relative to parent path.
256 * @param callback RPC response callback
257 * @param filterPath parent path to requested data
258 * @param fields paths to specific fields that are selected under parent path
259 * @return asynchronous completion token with read {@link NormalizedNode} wrapped in {@link Optional} instance
261 public ListenableFuture<Optional<NormalizedNode>> getConfigRunningData(
262 final FutureCallback<DOMRpcResult> callback, final Optional<YangInstanceIdentifier> filterPath,
263 final List<YangInstanceIdentifier> fields) {
264 if (fields.isEmpty()) {
265 // RFC doesn't allow to build subtree filter that would expect just empty element in response
266 return Futures.immediateFailedFuture(new IllegalArgumentException(
267 "Failed to build NETCONF GET-CONFIG RPC: provided list of fields is empty; filter path: "
270 final ListenableFuture<? extends DOMRpcResult> response = getConfigRunning(callback, filterPath, fields);
271 return extractData(filterPath, response);
275 * Calling GET RPC with subtree filter that is specified by {@link YangInstanceIdentifier}.
277 * @param callback RPC response callback
278 * @param filterPath path to requested data
279 * @return asynchronous completion token with read {@link NormalizedNode} wrapped in {@link Optional} instance
281 public ListenableFuture<Optional<NormalizedNode>> getData(final FutureCallback<DOMRpcResult> callback,
282 final Optional<YangInstanceIdentifier> filterPath) {
283 return extractData(filterPath, get(callback, filterPath));
287 * Calling GET RPC with subtree filter tha tis specified by parent {@link YangInstanceIdentifier} and list
288 * of specific fields that caller would like to read. Field paths are relative to parent path.
290 * @param callback RPC response callback
291 * @param filterPath parent path to requested data
292 * @param fields paths to specific fields that are selected under parent path
293 * @return asynchronous completion token with read {@link NormalizedNode} wrapped in {@link Optional} instance
295 public ListenableFuture<Optional<NormalizedNode>> getData(final FutureCallback<DOMRpcResult> callback,
296 final Optional<YangInstanceIdentifier> filterPath, final List<YangInstanceIdentifier> fields) {
297 if (fields.isEmpty()) {
298 // RFC doesn't allow to build subtree filter that would expect just empty element in response
299 return Futures.immediateFailedFuture(new IllegalArgumentException(
300 "Failed to build NETCONF GET RPC: provided list of fields is empty; filter path: " + filterPath));
302 final ListenableFuture<? extends DOMRpcResult> response = get(callback, filterPath, fields);
303 return extractData(filterPath, response);
306 private ListenableFuture<Optional<NormalizedNode>> extractData(final Optional<YangInstanceIdentifier> path,
307 final ListenableFuture<? extends DOMRpcResult> configRunning) {
308 return Futures.transform(configRunning, result -> {
309 checkArgument(result.getErrors().isEmpty(), "Unable to read data: %s, errors: %s", path,
311 final DataContainerChild dataNode = ((ContainerNode) result.getResult())
312 .findChildByArg(NetconfMessageTransformUtil.NETCONF_DATA_NODEID).get();
313 return transformer.selectFromDataStructure(dataNode, path.get());
314 }, MoreExecutors.directExecutor());
317 public ListenableFuture<? extends DOMRpcResult> getConfigRunning(final FutureCallback<DOMRpcResult> callback,
318 final Optional<YangInstanceIdentifier> filterPath) {
319 return getConfig(callback, NETCONF_RUNNING_QNAME, filterPath);
322 private ListenableFuture<? extends DOMRpcResult> getConfigRunning(final FutureCallback<DOMRpcResult> callback,
323 final Optional<YangInstanceIdentifier> filterPath, final List<YangInstanceIdentifier> fields) {
324 return getConfig(callback, NETCONF_RUNNING_QNAME, filterPath, fields);
327 public ListenableFuture<? extends DOMRpcResult> getConfigCandidate(final FutureCallback<DOMRpcResult> callback,
328 final Optional<YangInstanceIdentifier> filterPath) {
329 return getConfig(callback, NETCONF_CANDIDATE_QNAME, filterPath);
332 public ListenableFuture<? extends DOMRpcResult> get(final FutureCallback<DOMRpcResult> callback,
333 final Optional<YangInstanceIdentifier> filterPath) {
334 requireNonNull(callback);
336 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_GET_QNAME,
337 isFilterPresent(filterPath)
338 ? NetconfMessageTransformUtil.wrap(NETCONF_GET_NODEID,
339 toFilterStructure(filterPath.get(), mountContext.getEffectiveModelContext()))
340 : NetconfMessageTransformUtil.GET_RPC_CONTENT);
341 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
345 private ListenableFuture<? extends DOMRpcResult> get(final FutureCallback<DOMRpcResult> callback,
346 final Optional<YangInstanceIdentifier> filterPath, final List<YangInstanceIdentifier> fields) {
347 requireNonNull(callback);
349 final NormalizedNode rpcInput;
350 if (isFilterPresent(filterPath)) {
351 rpcInput = NetconfMessageTransformUtil.wrap(NETCONF_GET_NODEID, transformer.toFilterStructure(
352 Collections.singletonList(FieldsFilter.of(filterPath.get(), fields))));
353 } else if (containsEmptyPath(fields)) {
354 rpcInput = GET_RPC_CONTENT;
356 final DataContainerChild subtreeFilter = getSubtreeFilterFromRootFields(fields);
357 rpcInput = NetconfMessageTransformUtil.wrap(NETCONF_GET_NODEID, subtreeFilter);
359 final ListenableFuture<? extends DOMRpcResult> response = rpc.invokeRpc(NETCONF_GET_QNAME, rpcInput);
360 Futures.addCallback(response, callback, MoreExecutors.directExecutor());
364 private static boolean containsEmptyPath(final List<YangInstanceIdentifier> fields) {
365 return fields.stream().anyMatch(YangInstanceIdentifier::isEmpty);
368 private DataContainerChild getSubtreeFilterFromRootFields(final List<YangInstanceIdentifier> fields) {
369 final Map<YangInstanceIdentifier, List<YangInstanceIdentifier>> getConfigEntries = fields.stream()
371 final YangInstanceIdentifier rootPath = YangInstanceIdentifier.create(
372 Iterables.limit(fieldPath.getPathArguments(), 1));
373 final YangInstanceIdentifier updatedFieldPath = YangInstanceIdentifier.create(
374 Iterables.skip(fieldPath.getPathArguments(), 1));
375 return new SimpleEntry<>(rootPath, updatedFieldPath);
377 .collect(Collectors.groupingBy(SimpleEntry::getKey,
378 Collectors.mapping(SimpleEntry::getValue, Collectors.toList())));
379 final List<FieldsFilter> fieldsFilters = getConfigEntries.keySet().stream()
380 .map(rootPath -> FieldsFilter.of(rootPath, getConfigEntries.get(rootPath)))
381 .collect(Collectors.toList());
382 return transformer.toFilterStructure(fieldsFilters);
385 private static boolean isFilterPresent(final Optional<YangInstanceIdentifier> filterPath) {
386 return filterPath.isPresent() && !filterPath.get().isEmpty();
389 public ListenableFuture<? extends DOMRpcResult> editConfigCandidate(
390 final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild editStructure,
391 final ModifyAction modifyAction, final boolean rollback) {
392 return editConfig(callback, NETCONF_CANDIDATE_QNAME, editStructure, Optional.of(modifyAction), rollback);
395 public ListenableFuture<? extends DOMRpcResult> editConfigCandidate(
396 final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild editStructure,
397 final boolean rollback) {
398 return editConfig(callback, NETCONF_CANDIDATE_QNAME, editStructure, Optional.empty(), rollback);
401 public ListenableFuture<? extends DOMRpcResult> editConfigRunning(
402 final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild editStructure,
403 final ModifyAction modifyAction, final boolean rollback) {
404 return editConfig(callback, NETCONF_RUNNING_QNAME, editStructure, Optional.of(modifyAction), rollback);
407 public ListenableFuture<? extends DOMRpcResult> editConfigRunning(
408 final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild editStructure,
409 final boolean rollback) {
410 return editConfig(callback, NETCONF_RUNNING_QNAME, editStructure, Optional.empty(), rollback);
413 public ListenableFuture<? extends DOMRpcResult> editConfig(
414 final FutureCallback<? super DOMRpcResult> callback, final QName datastore,
415 final DataContainerChild editStructure, final Optional<ModifyAction> modifyAction,
416 final boolean rollback) {
417 requireNonNull(callback);
419 final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_EDIT_CONFIG_QNAME,
420 getEditConfigContent(requireNonNull(datastore), requireNonNull(editStructure), modifyAction, rollback));
422 Futures.addCallback(future, callback, MoreExecutors.directExecutor());
426 public ChoiceNode createEditConfigStructure(final Optional<NormalizedNode> lastChild,
427 final Optional<ModifyAction> operation,
428 final YangInstanceIdentifier dataPath) {
429 return Builders.choiceBuilder()
430 .withNodeIdentifier(EDIT_CONTENT_NODEID)
431 .withChild(transformer.createEditConfigStructure(lastChild, dataPath, operation))
435 private static ContainerNode getEditConfigContent(final QName datastore, final DataContainerChild editStructure,
436 final Optional<ModifyAction> defaultOperation, final boolean rollback) {
437 final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> editBuilder =
438 Builders.containerBuilder().withNodeIdentifier(NETCONF_EDIT_CONFIG_NODEID);
441 editBuilder.withChild(getTargetNode(datastore));
444 if (defaultOperation.isPresent()) {
445 final String opString = defaultOperation.get().name().toLowerCase(Locale.ROOT);
446 editBuilder.withChild(Builders.leafBuilder().withNodeIdentifier(NETCONF_DEFAULT_OPERATION_NODEID)
447 .withValue(opString).build());
452 editBuilder.withChild(Builders.leafBuilder().withNodeIdentifier(NETCONF_ERROR_OPTION_NODEID)
453 .withValue(ROLLBACK_ON_ERROR_OPTION).build());
457 editBuilder.withChild(editStructure);
458 return editBuilder.build();
461 public static @NonNull ContainerNode getSourceNode(final QName datastore) {
462 return Builders.containerBuilder()
463 .withNodeIdentifier(NETCONF_SOURCE_NODEID)
464 .withChild(Builders.choiceBuilder()
465 .withNodeIdentifier(CONFIG_SOURCE_NODEID)
466 .withChild(ImmutableNodes.leafNode(datastore, Empty.value()))
471 public static @NonNull ContainerNode getLockContent(final QName datastore) {
472 return Builders.containerBuilder().withNodeIdentifier(NETCONF_LOCK_NODEID)
473 .withChild(getTargetNode(datastore)).build();
476 public static @NonNull ContainerNode getTargetNode(final QName datastore) {
477 return Builders.containerBuilder().withNodeIdentifier(NETCONF_TARGET_NODEID)
478 .withChild(Builders.choiceBuilder().withNodeIdentifier(CONFIG_TARGET_NODEID).withChild(
479 Builders.leafBuilder().withNodeIdentifier(toId(datastore)).withValue(Empty.value()).build())
483 public static @NonNull ContainerNode getCopyConfigContent(final QName source, final QName target) {
484 return Builders.containerBuilder().withNodeIdentifier(NETCONF_COPY_CONFIG_NODEID)
485 .withChild(getTargetNode(target)).withChild(getSourceNode(source)).build();
488 public static @NonNull ContainerNode getValidateContent(final QName source) {
489 return Builders.containerBuilder().withNodeIdentifier(NETCONF_VALIDATE_NODEID)
490 .withChild(getSourceNode(source)).build();
493 public static @NonNull ContainerNode getUnLockContent(final QName datastore) {
494 return Builders.containerBuilder().withNodeIdentifier(NETCONF_UNLOCK_NODEID)
495 .withChild(getTargetNode(datastore)).build();