Code Review / netconf.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Update MRI projects for Aluminium
[netconf.git] / netconf / sal-netconf-connector / src / main / java / org / opendaylight / netconf / sal / connect / netconf / util / NetconfBaseOps.java
diff --git a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOps.java b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOps.java
index 7564e755e72e4c32c1fb1565921fd7d3ec0f39aa..8994b7f4421a89c84060d848b8d65a6e74007ee5 100644 (file)
--- a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOps.java
+++ b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/util/NetconfBaseOps.java
@@ -9,8 +9,10 @@ package org.opendaylight.netconf.sal.connect.netconf.util;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static java.util.Objects.requireNonNull;
+import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.COMMIT_RPC_CONTENT;
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.EDIT_CONTENT_NODEID;
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_CANDIDATE_QNAME;
+import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_COMMIT_PATH;
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_COPY_CONFIG_NODEID;
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_COPY_CONFIG_PATH;
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_DEFAULT_OPERATION_NODEID;
@@ -30,6 +32,7 @@ import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTr
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_UNLOCK_NODEID;
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_UNLOCK_PATH;
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_VALIDATE_NODEID;
+import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_VALIDATE_PATH;
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.ROLLBACK_ON_ERROR_OPTION;
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toFilterStructure;
 import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toId;
@@ -53,13 +56,14 @@ import org.opendaylight.yangtools.yang.common.Empty;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 
 /**
  * Provides base operations for netconf e.g. get, get-config, edit-config, (un)lock, commit etc.
@@ -74,7 +78,7 @@ public final class NetconfBaseOps {
     private final RpcStructureTransformer transformer;
 
     @Deprecated
-    public NetconfBaseOps(final DOMRpcService rpc, final SchemaContext schemaContext) {
+    public NetconfBaseOps(final DOMRpcService rpc, final EffectiveModelContext schemaContext) {
         this(rpc, new EmptyMountPointContext(schemaContext));
     }
 
@@ -90,106 +94,112 @@ public final class NetconfBaseOps {
         }
     }
 
-    public ListenableFuture<DOMRpcResult> lock(final FutureCallback<DOMRpcResult> callback, final QName datastore) {
+    public ListenableFuture<? extends DOMRpcResult> lock(final FutureCallback<DOMRpcResult> callback,
+            final QName datastore) {
         requireNonNull(callback);
         requireNonNull(datastore);
 
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH, getLockContent(datastore));
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH,
+                getLockContent(datastore));
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public ListenableFuture<DOMRpcResult> lockCandidate(final FutureCallback<DOMRpcResult> callback) {
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH,
+    public ListenableFuture<? extends DOMRpcResult> lockCandidate(final FutureCallback<DOMRpcResult> callback) {
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH,
             getLockContent(NETCONF_CANDIDATE_QNAME));
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public ListenableFuture<DOMRpcResult> lockRunning(final FutureCallback<DOMRpcResult> callback) {
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH,
+    public ListenableFuture<? extends DOMRpcResult> lockRunning(final FutureCallback<DOMRpcResult> callback) {
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_LOCK_PATH,
             getLockContent(NETCONF_RUNNING_QNAME));
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public ListenableFuture<DOMRpcResult> unlock(final FutureCallback<DOMRpcResult> callback, final QName datastore) {
+    public ListenableFuture<? extends DOMRpcResult> unlock(final FutureCallback<DOMRpcResult> callback,
+            final QName datastore) {
         requireNonNull(callback);
         requireNonNull(datastore);
 
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH, getUnLockContent(datastore));
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH,
+                getUnLockContent(datastore));
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public ListenableFuture<DOMRpcResult> unlockRunning(final FutureCallback<DOMRpcResult> callback) {
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH,
+    public ListenableFuture<? extends DOMRpcResult> unlockRunning(final FutureCallback<DOMRpcResult> callback) {
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH,
             getUnLockContent(NETCONF_RUNNING_QNAME));
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public ListenableFuture<DOMRpcResult> unlockCandidate(final FutureCallback<DOMRpcResult> callback) {
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH,
+    public ListenableFuture<? extends DOMRpcResult> unlockCandidate(final FutureCallback<DOMRpcResult> callback) {
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_UNLOCK_PATH,
             getUnLockContent(NETCONF_CANDIDATE_QNAME));
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public ListenableFuture<DOMRpcResult> discardChanges(final FutureCallback<DOMRpcResult> callback) {
+    public ListenableFuture<? extends DOMRpcResult> discardChanges(final FutureCallback<DOMRpcResult> callback) {
         requireNonNull(callback);
 
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_DISCARD_CHANGES_PATH, null);
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_DISCARD_CHANGES_PATH, null);
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public ListenableFuture<DOMRpcResult> commit(final FutureCallback<DOMRpcResult> callback) {
+    public ListenableFuture<? extends DOMRpcResult> commit(final FutureCallback<DOMRpcResult> callback) {
         requireNonNull(callback);
 
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NetconfMessageTransformUtil.NETCONF_COMMIT_PATH,
-            NetconfMessageTransformUtil.COMMIT_RPC_CONTENT);
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_COMMIT_PATH, COMMIT_RPC_CONTENT);
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public ListenableFuture<DOMRpcResult> validate(final FutureCallback<DOMRpcResult> callback, final QName datastore) {
+    public ListenableFuture<? extends DOMRpcResult> validate(final FutureCallback<DOMRpcResult> callback,
+            final QName datastore) {
         requireNonNull(callback);
 
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NetconfMessageTransformUtil.NETCONF_VALIDATE_PATH,
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_VALIDATE_PATH,
             getValidateContent(requireNonNull(datastore)));
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public ListenableFuture<DOMRpcResult> validateCandidate(final FutureCallback<DOMRpcResult> callback) {
+    public ListenableFuture<? extends DOMRpcResult> validateCandidate(final FutureCallback<DOMRpcResult> callback) {
         return validate(callback, NETCONF_CANDIDATE_QNAME);
     }
 
-    public ListenableFuture<DOMRpcResult> validateRunning(final FutureCallback<DOMRpcResult> callback) {
+    public ListenableFuture<? extends DOMRpcResult> validateRunning(final FutureCallback<DOMRpcResult> callback) {
         return validate(callback, NETCONF_RUNNING_QNAME);
     }
 
-    public ListenableFuture<DOMRpcResult> copyConfig(final FutureCallback<DOMRpcResult> callback,
-                                                     final QName source, final QName target) {
+    public ListenableFuture<? extends DOMRpcResult> copyConfig(final FutureCallback<DOMRpcResult> callback,
+                                                               final QName source, final QName target) {
         requireNonNull(callback);
 
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_COPY_CONFIG_PATH,
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_COPY_CONFIG_PATH,
             getCopyConfigContent(requireNonNull(source), requireNonNull(target)));
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public ListenableFuture<DOMRpcResult> copyRunningToCandidate(final FutureCallback<DOMRpcResult> callback) {
+    public ListenableFuture<? extends DOMRpcResult> copyRunningToCandidate(
+            final FutureCallback<DOMRpcResult> callback) {
         return copyConfig(callback, NETCONF_RUNNING_QNAME, NETCONF_CANDIDATE_QNAME);
     }
 
-    public ListenableFuture<DOMRpcResult> getConfig(final FutureCallback<DOMRpcResult> callback, final QName datastore,
-                                                    final Optional<YangInstanceIdentifier> filterPath) {
+    public ListenableFuture<? extends DOMRpcResult> getConfig(final FutureCallback<DOMRpcResult> callback,
+                                                              final QName datastore,
+                                                              final Optional<YangInstanceIdentifier> filterPath) {
         requireNonNull(callback);
         requireNonNull(datastore);
 
-        final ListenableFuture<DOMRpcResult> future;
+        final ListenableFuture<? extends DOMRpcResult> future;
         if (isFilterPresent(filterPath)) {
             final DataContainerChild<?, ?> node = transformer.toFilterStructure(filterPath.get());
             future = rpc.invokeRpc(NETCONF_GET_CONFIG_PATH,
@@ -205,45 +215,43 @@ public final class NetconfBaseOps {
 
     public ListenableFuture<Optional<NormalizedNode<?, ?>>> getConfigRunningData(
             final FutureCallback<DOMRpcResult> callback, final Optional<YangInstanceIdentifier> filterPath) {
-        final ListenableFuture<DOMRpcResult> configRunning = getConfigRunning(callback, filterPath);
-        return extractData(filterPath, configRunning);
+        return extractData(filterPath, getConfigRunning(callback, filterPath));
     }
 
     public ListenableFuture<Optional<NormalizedNode<?, ?>>> getData(final FutureCallback<DOMRpcResult> callback,
                                                                     final Optional<YangInstanceIdentifier> filterPath) {
-        final ListenableFuture<DOMRpcResult> configRunning = get(callback, filterPath);
-        return extractData(filterPath, configRunning);
+        return extractData(filterPath, get(callback, filterPath));
     }
 
     private ListenableFuture<Optional<NormalizedNode<?, ?>>> extractData(
-            final Optional<YangInstanceIdentifier> path, final ListenableFuture<DOMRpcResult> configRunning) {
+            final Optional<YangInstanceIdentifier> path, final ListenableFuture<? extends DOMRpcResult> configRunning) {
         return Futures.transform(configRunning, result -> {
             checkArgument(result.getErrors().isEmpty(), "Unable to read data: %s, errors: %s", path,
                 result.getErrors());
-            final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataNode =
-                    ((ContainerNode) result.getResult()).getChild(NetconfMessageTransformUtil.NETCONF_DATA_NODEID)
-                    .get();
+            final DataContainerChild<?, ?> dataNode = ((ContainerNode) result.getResult())
+                    .getChild(NetconfMessageTransformUtil.NETCONF_DATA_NODEID).get();
             return transformer.selectFromDataStructure(dataNode, path.get());
         }, MoreExecutors.directExecutor());
     }
 
-    public ListenableFuture<DOMRpcResult> getConfigRunning(final FutureCallback<DOMRpcResult> callback,
-                                                           final Optional<YangInstanceIdentifier> filterPath) {
+    public ListenableFuture<? extends DOMRpcResult> getConfigRunning(final FutureCallback<DOMRpcResult> callback,
+            final Optional<YangInstanceIdentifier> filterPath) {
         return getConfig(callback, NETCONF_RUNNING_QNAME, filterPath);
     }
 
-    public ListenableFuture<DOMRpcResult> getConfigCandidate(final FutureCallback<DOMRpcResult> callback,
-                                                             final Optional<YangInstanceIdentifier> filterPath) {
+    public ListenableFuture<? extends DOMRpcResult> getConfigCandidate(final FutureCallback<DOMRpcResult> callback,
+            final Optional<YangInstanceIdentifier> filterPath) {
         return getConfig(callback, NETCONF_CANDIDATE_QNAME, filterPath);
     }
 
-    public ListenableFuture<DOMRpcResult> get(final FutureCallback<DOMRpcResult> callback,
-                                              final Optional<YangInstanceIdentifier> filterPath) {
+    public ListenableFuture<? extends DOMRpcResult> get(final FutureCallback<DOMRpcResult> callback,
+                                                        final Optional<YangInstanceIdentifier> filterPath) {
         requireNonNull(callback);
 
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_GET_PATH, isFilterPresent(filterPath)
-            ? NetconfMessageTransformUtil.wrap(NETCONF_GET_NODEID,
-                toFilterStructure(filterPath.get(), mountContext.getSchemaContext()))
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_GET_PATH,
+                isFilterPresent(filterPath)
+                    ? NetconfMessageTransformUtil.wrap(NETCONF_GET_NODEID,
+                        toFilterStructure(filterPath.get(), mountContext.getSchemaContext()))
                     : NetconfMessageTransformUtil.GET_RPC_CONTENT);
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
@@ -253,48 +261,50 @@ public final class NetconfBaseOps {
         return filterPath.isPresent() && !filterPath.get().isEmpty();
     }
 
-    public ListenableFuture<DOMRpcResult> editConfigCandidate(final FutureCallback<? super DOMRpcResult> callback,
-                                                              final DataContainerChild<?, ?> editStructure,
-                                                              final ModifyAction modifyAction, final boolean rollback) {
+    public ListenableFuture<? extends DOMRpcResult> editConfigCandidate(
+            final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild<?, ?> editStructure,
+            final ModifyAction modifyAction, final boolean rollback) {
         return editConfig(callback, NETCONF_CANDIDATE_QNAME, editStructure, Optional.of(modifyAction), rollback);
     }
 
-    public ListenableFuture<DOMRpcResult> editConfigCandidate(final FutureCallback<? super DOMRpcResult> callback,
-                                                              final DataContainerChild<?, ?> editStructure,
-                                                              final boolean rollback) {
+    public ListenableFuture<? extends DOMRpcResult> editConfigCandidate(
+            final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild<?, ?> editStructure,
+            final boolean rollback) {
         return editConfig(callback, NETCONF_CANDIDATE_QNAME, editStructure, Optional.empty(), rollback);
     }
 
-    public ListenableFuture<DOMRpcResult> editConfigRunning(final FutureCallback<? super DOMRpcResult> callback,
-                                                            final DataContainerChild<?, ?> editStructure,
-                                                            final ModifyAction modifyAction, final boolean rollback) {
+    public ListenableFuture<? extends DOMRpcResult> editConfigRunning(
+            final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild<?, ?> editStructure,
+            final ModifyAction modifyAction, final boolean rollback) {
         return editConfig(callback, NETCONF_RUNNING_QNAME, editStructure, Optional.of(modifyAction), rollback);
     }
 
-    public ListenableFuture<DOMRpcResult> editConfigRunning(final FutureCallback<? super DOMRpcResult> callback,
-                                                            final DataContainerChild<?, ?> editStructure,
-                                                            final boolean rollback) {
+    public ListenableFuture<? extends DOMRpcResult> editConfigRunning(
+            final FutureCallback<? super DOMRpcResult> callback, final DataContainerChild<?, ?> editStructure,
+            final boolean rollback) {
         return editConfig(callback, NETCONF_RUNNING_QNAME, editStructure, Optional.empty(), rollback);
     }
 
-    public ListenableFuture<DOMRpcResult> editConfig(
+    public ListenableFuture<? extends DOMRpcResult> editConfig(
             final FutureCallback<? super DOMRpcResult> callback, final QName datastore,
             final DataContainerChild<?, ?> editStructure, final Optional<ModifyAction> modifyAction,
             final boolean rollback) {
         requireNonNull(callback);
 
-        final ListenableFuture<DOMRpcResult> future = rpc.invokeRpc(NETCONF_EDIT_CONFIG_PATH,
+        final ListenableFuture<? extends DOMRpcResult> future = rpc.invokeRpc(NETCONF_EDIT_CONFIG_PATH,
                 getEditConfigContent(requireNonNull(datastore), requireNonNull(editStructure), modifyAction, rollback));
 
         Futures.addCallback(future, callback, MoreExecutors.directExecutor());
         return future;
     }
 
-    public DataContainerChild<?, ?> createEditConfigStrcture(final Optional<NormalizedNode<?, ?>> lastChild,
-                                                             final Optional<ModifyAction> operation,
-                                                             final YangInstanceIdentifier dataPath) {
-        final DOMSourceAnyxmlNode configContent = transformer.createEditConfigStructure(lastChild, dataPath, operation);
-        return Builders.choiceBuilder().withNodeIdentifier(EDIT_CONTENT_NODEID).withChild(configContent).build();
+    public ChoiceNode createEditConfigStrcture(final Optional<NormalizedNode<?, ?>> lastChild,
+                                               final Optional<ModifyAction> operation,
+                                               final YangInstanceIdentifier dataPath) {
+        return Builders.choiceBuilder()
+                .withNodeIdentifier(EDIT_CONTENT_NODEID)
+                .withChild(transformer.createEditConfigStructure(lastChild, dataPath, operation))
+                .build();
     }
 
     private static ContainerNode getEditConfigContent(
@@ -324,11 +334,14 @@ public final class NetconfBaseOps {
         return editBuilder.build();
     }
 
-    public static DataContainerChild<?, ?> getSourceNode(final QName datastore) {
-        return Builders.containerBuilder().withNodeIdentifier(NETCONF_SOURCE_NODEID)
-                .withChild(Builders.choiceBuilder().withNodeIdentifier(CONFIG_SOURCE_NODEID).withChild(
-                    Builders.leafBuilder().withNodeIdentifier(toId(datastore)).withValue(Empty.getInstance()).build())
-                    .build()).build();
+    public static ContainerNode getSourceNode(final QName datastore) {
+        return Builders.containerBuilder()
+                .withNodeIdentifier(NETCONF_SOURCE_NODEID)
+                .withChild(Builders.choiceBuilder()
+                    .withNodeIdentifier(CONFIG_SOURCE_NODEID)
+                    .withChild(ImmutableNodes.leafNode(datastore, Empty.getInstance()))
+                    .build())
+                .build();
     }
 
     public static ContainerNode getLockContent(final QName datastore) {
@@ -336,24 +349,24 @@ public final class NetconfBaseOps {
                 .withChild(getTargetNode(datastore)).build();
     }
 
-    public static DataContainerChild<?, ?> getTargetNode(final QName datastore) {
+    public static ContainerNode getTargetNode(final QName datastore) {
         return Builders.containerBuilder().withNodeIdentifier(NETCONF_TARGET_NODEID)
                 .withChild(Builders.choiceBuilder().withNodeIdentifier(CONFIG_TARGET_NODEID).withChild(
                     Builders.leafBuilder().withNodeIdentifier(toId(datastore)).withValue(Empty.getInstance()).build())
                     .build()).build();
     }
 
-    public static NormalizedNode<?, ?> getCopyConfigContent(final QName source, final QName target) {
+    public static ContainerNode getCopyConfigContent(final QName source, final QName target) {
         return Builders.containerBuilder().withNodeIdentifier(NETCONF_COPY_CONFIG_NODEID)
                 .withChild(getTargetNode(target)).withChild(getSourceNode(source)).build();
     }
 
-    public static NormalizedNode<?, ?> getValidateContent(final QName source) {
+    public static ContainerNode getValidateContent(final QName source) {
         return Builders.containerBuilder().withNodeIdentifier(NETCONF_VALIDATE_NODEID)
                 .withChild(getSourceNode(source)).build();
     }
 
-    public static NormalizedNode<?, ?> getUnLockContent(final QName datastore) {
+    public static ContainerNode getUnLockContent(final QName datastore) {
         return Builders.containerBuilder().withNodeIdentifier(NETCONF_UNLOCK_NODEID)
                 .withChild(getTargetNode(datastore)).build();
     }
Netconf