<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-connector" version="${project.version}">
- <feature version="[10,11)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[6,7)">odl-mdsal-broker</feature>
- <feature version="[0.16,1)">odl-aaa-encryption-service</feature>
+ <feature version="[11,12)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[7,8)">odl-mdsal-broker</feature>
+ <feature version="[0.17,1)">odl-aaa-encryption-service</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-aaa-netconf-plugin-no-cluster">
<feature name="odl-aaa-netconf-plugin-no-cluster">
- <feature version="[0.16,1)">odl-aaa-shiro</feature>
+ <feature version="[0.17,1)">odl-aaa-shiro</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-aaa-netconf-plugin">
<feature name="odl-aaa-netconf-plugin">
- <feature version="[0.16,1)">odl-aaa-shiro</feature>
+ <feature version="[0.17,1)">odl-aaa-shiro</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-api" version="${project.version}">
- <feature version="[11,12)">odl-netty-4</feature>
- <feature version="[9,10)">odl-yangtools-parser-api</feature>
- <feature version="[10,11)">odl-mdsal-model-rfc8525</feature>
- <feature version="[10,11)">odl-mdsal-model-rfc8342</feature>
+ <feature version="[12,13)">odl-netty-4</feature>
+ <feature version="[10,11)">odl-yangtools-parser-api</feature>
+ <feature version="[11,12)">odl-mdsal-model-rfc8525</feature>
+ <feature version="[11,12)">odl-mdsal-model-rfc8342</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-client-${project.version}">
<feature name="odl-netconf-client" version="${project.version}">
- <feature version="[6,7)">odl-controller-exp-netty-config</feature>
+ <feature version="[7,8)">odl-controller-exp-netty-config</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-impl-${project.version}">
<feature name="odl-netconf-impl" version="${project.version}">
- <feature version="[6,7)">odl-controller-exp-netty-config</feature>
+ <feature version="[7,8)">odl-controller-exp-netty-config</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-netconf-netty-util-${project.version}">
<feature name="odl-netconf-netty-util" version="${project.version}">
- <feature version="[11,12)">odl-netty-4</feature>
- <feature version="[0.16,1)">odl-aaa-encryption-service</feature>
+ <feature version="[12,13)">odl-netty-4</feature>
+ <feature version="[0.17,1)">odl-aaa-encryption-service</feature>
</feature>
</features>
<?xml version="1.0" encoding="UTF-8"?>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-netconf-notifications-impl-${project.version}">
<feature name="odl-netconf-notifications-impl" version="${project.version}">
- <feature version="[10,11)">odl-mdsal-binding-runtime</feature>
+ <feature version="[11,12)">odl-mdsal-binding-runtime</feature>
</feature>
</features>
<configfile finalname="etc/netconf.cfg">
mvn:org.opendaylight.netconf/netconf-util/${project.version}/cfg/config
</configfile>
- <feature version="[9,10)">odl-yangtools-codec</feature>
+ <feature version="[10,11)">odl-yangtools-codec</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-mdsal-apidocs" version="${project.version}">
- <feature version="[11,12)">odl-jackson-2.13</feature>
+ <feature version="[12,13)">odl-jackson-2.13</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-restconf-common" version="${project.version}">
- <feature version="[11,12)">odl-karaf-feat-jetty</feature>
- <feature version="[9,10)">odl-yangtools-export</feature>
- <feature version="[10,11)">odl-mdsal-model-rfc8040</feature>
- <feature version="[10,11)">odl-mdsal-model-rfc8525</feature>
- <feature version="[6,7)">odl-mdsal-broker</feature>
- <feature version="[0.16,1)">odl-aaa-shiro</feature>
+ <feature version="[12,13)">odl-karaf-feat-jetty</feature>
+ <feature version="[10,11)">odl-yangtools-export</feature>
+ <feature version="[11,12)">odl-mdsal-model-rfc8040</feature>
+ <feature version="[11,12)">odl-mdsal-model-rfc8525</feature>
+ <feature version="[7,8)">odl-mdsal-broker</feature>
+ <feature version="[0.17,1)">odl-aaa-shiro</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-restconf-nb-${project.version}">
<feature name="odl-restconf-nb" version="${project.version}">
- <feature version="[10,11)">odl-mdsal-model-rfc8072</feature>
- <feature version="[6,7)">odl-controller-exp-netty-config</feature>
+ <feature version="[11,12)">odl-mdsal-model-rfc8072</feature>
+ <feature version="[7,8)">odl-controller-exp-netty-config</feature>
<configfile finalname="etc/org.opendaylight.restconf.nb.rfc8040.cfg">
mvn:org.opendaylight.netconf/restconf-nb/${project.version}/cfg/config
</configfile>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-yanglib" version="${project.version}">
- <feature version="[11,12)">odl-karaf-feat-jetty</feature>
- <feature version="[10,11)">odl-mdsal-model-rfc8525</feature>
+ <feature version="[12,13)">odl-karaf-feat-jetty</feature>
+ <feature version="[11,12)">odl-mdsal-model-rfc8525</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf-dist-static</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.netconf</groupId>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>4.0.2</version>
+ <version>5.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>6.0.3</version>
+ <version>7.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
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.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
private static final DOMRpcService RPC_SERVICE_VOID_INVOKER = new DOMRpcService() {
@Override
- public FluentFuture<DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
+ public FluentFuture<DOMRpcResult> invokeRpc(final QName type, final ContainerNode input) {
return immediateFluentFuture(new DefaultDOMRpcResult(null, List.of()));
}
private static final DOMRpcService RPC_SERVICE_FAILED_INVOCATION = new DOMRpcService() {
@Override
- public FluentFuture<DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
+ public FluentFuture<DOMRpcResult> invokeRpc(final QName type, final ContainerNode input) {
return immediateFailedFluentFuture(new DOMRpcException("rpc invocation not implemented yet") {
private static final long serialVersionUID = 1L;
});
private final DOMRpcService rpcServiceSuccessfulInvocation = new DOMRpcService() {
@Override
- public FluentFuture<DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
- final Collection<DataContainerChild> children = ((ContainerNode) input).body();
+ public FluentFuture<DOMRpcResult> invokeRpc(final QName type, final ContainerNode input) {
+ final Collection<DataContainerChild> children = input.body();
final Module module = SCHEMA_CONTEXT.findModules(type.getNamespace()).stream()
.findFirst().orElse(null);
final RpcDefinition rpcDefinition = getRpcDefinitionFromModule(module, module.getNamespace(),
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
import akka.pattern.Patterns;
import akka.util.Timeout;
import com.google.common.collect.ImmutableList;
-import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.Collection;
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.concurrent.Future;
}
@Override
- public FluentFuture<DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
+ public ListenableFuture<DOMRpcResult> invokeRpc(final QName type, final ContainerNode input) {
LOG.trace("{}: Rpc operation invoked with schema type: {} and node: {}.", id, type, input);
final NormalizedNodeMessage normalizedNodeMessage = input != null
if (normalizedNodeMessageResult == null) {
result = new DefaultDOMRpcResult(ImmutableList.copyOf(errors));
} else {
- result = new DefaultDOMRpcResult(normalizedNodeMessageResult.getNode(), errors);
+ result = new DefaultDOMRpcResult((ContainerNode) normalizedNodeMessageResult.getNode(), errors);
}
settableFuture.set(result);
}
}, actorSystem.dispatcher());
- return FluentFuture.from(settableFuture);
+ return settableFuture;
}
@Override
import org.opendaylight.netconf.topology.singleton.messages.transactions.NewWriteTransactionRequest;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
deviceRpc);
final ListenableFuture<? extends DOMRpcResult> rpcResult = deviceRpc.invokeRpc(qname,
- normalizedNodeMessage != null ? normalizedNodeMessage.getNode() : null);
+ normalizedNodeMessage != null ? (ContainerNode) normalizedNodeMessage.getNode() : null);
Futures.addCallback(rpcResult, new FutureCallback<DOMRpcResult>() {
@Override
import org.opendaylight.netconf.topology.singleton.messages.rpc.InvokeRpcMessageReply;
import org.opendaylight.netconf.topology.singleton.messages.transactions.EmptyReadResponse;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return;
}
- if (response instanceof NormalizedNodeMessage) {
- final NormalizedNodeMessage data = (NormalizedNodeMessage) response;
+ if (response instanceof NormalizedNodeMessage data) {
settableFuture.set(Optional.of(data.getNode()));
}
}
if (reply.getNormalizedNodeMessage() == null) {
return new DefaultDOMRpcResult(new ArrayList<>(reply.getRpcErrors()));
} else {
- return new DefaultDOMRpcResult(reply.getNormalizedNodeMessage().getNode(), reply.getRpcErrors());
+ return new DefaultDOMRpcResult((ContainerNode) reply.getNormalizedNodeMessage().getNode(),
+ reply.getRpcErrors());
}
}
}
final var rpcService = router.getRpcService();
deviceRpcService = new Rpcs.Normalized() {
@Override
- public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
+ public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final ContainerNode input) {
return rpcService.invokeRpc(type, input);
}
private void testDOMRpcService(final DOMRpcService domRpcService)
throws InterruptedException, ExecutionException, TimeoutException {
- testPutTopRpc(domRpcService, new DefaultDOMRpcResult((NormalizedNode)null));
+ testPutTopRpc(domRpcService, new DefaultDOMRpcResult((ContainerNode)null));
testPutTopRpc(domRpcService, null);
testPutTopRpc(domRpcService, new DefaultDOMRpcResult(ImmutableList.of(
RpcResultBuilder.newError(ErrorType.APPLICATION, new ErrorTag("tag1"), "error1"),
testRpc(domRpcService, getTopRpcSchemaPath, getTopInput, result);
}
- private void testRpc(final DOMRpcService domRpcService, final QName qname, final NormalizedNode input,
+ private void testRpc(final DOMRpcService domRpcService, final QName qname, final ContainerNode input,
final DOMRpcResult result) throws InterruptedException, ExecutionException, TimeoutException {
final FluentFuture<DOMRpcResult> future = result == null ? FluentFutures.immediateNullFluentFuture()
: FluentFutures.immediateFluentFuture(result);
}
assertNotNull(actual);
- assertEquals(result.getResult(), actual.getResult());
+ assertEquals(result.value(), actual.value());
- assertEquals(result.getErrors().size(), actual.getErrors().size());
- Iterator<? extends RpcError> iter1 = result.getErrors().iterator();
- Iterator<? extends RpcError> iter2 = actual.getErrors().iterator();
+ assertEquals(result.errors().size(), actual.errors().size());
+ Iterator<? extends RpcError> iter1 = result.errors().iterator();
+ Iterator<? extends RpcError> iter2 = actual.errors().iterator();
while (iter1.hasNext() && iter2.hasNext()) {
RpcError err1 = iter1.next();
RpcError err2 = iter2.next();
}
}
- private void testFailedRpc(final DOMRpcService domRpcService, final QName qname, final NormalizedNode input)
+ private void testFailedRpc(final DOMRpcService domRpcService, final QName qname, final ContainerNode input)
throws InterruptedException, TimeoutException {
try {
- invokeRpc(domRpcService, qname, input, FluentFutures.immediateFailedFluentFuture(
- new ClusteringRpcException("mock")));
+ invokeRpc(domRpcService, qname, input, Futures.immediateFailedFuture(new ClusteringRpcException("mock")));
fail("Expected exception");
} catch (ExecutionException e) {
assertTrue(e.getCause() instanceof ClusteringRpcException);
}
}
- private DOMRpcResult invokeRpc(final DOMRpcService domRpcService, final QName qname, final NormalizedNode input,
- final FluentFuture<DOMRpcResult> returnFuture)
+ private DOMRpcResult invokeRpc(final DOMRpcService domRpcService, final QName qname, final ContainerNode input,
+ final ListenableFuture<DOMRpcResult> returnFuture)
throws InterruptedException, ExecutionException, TimeoutException {
topRpcImplementation.init(returnFuture);
final ListenableFuture<? extends DOMRpcResult> resultFuture = domRpcService.invokeRpc(qname, input);
private static class TopDOMRpcImplementation implements DOMRpcImplementation {
private volatile SettableFuture<Entry<DOMRpcIdentifier, NormalizedNode>> rpcInvokedFuture;
- private volatile FluentFuture<DOMRpcResult> returnFuture;
+ private volatile ListenableFuture<DOMRpcResult> returnFuture;
@Override
- public FluentFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode input) {
+ public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final ContainerNode input) {
rpcInvokedFuture.set(Map.entry(rpc, input));
return returnFuture;
}
- void init(final FluentFuture<DOMRpcResult> retFuture) {
+ void init(final ListenableFuture<DOMRpcResult> retFuture) {
returnFuture = retFuture;
rpcInvokedFuture = SettableFuture.create();
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
import org.opendaylight.netconf.sal.connect.netconf.NetconfDevice.SchemaResourcesDTO;
import org.opendaylight.netconf.sal.connect.netconf.NetconfStateSchemasResolverImpl;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactoryConfiguration;
+import org.opendaylight.yangtools.yang.model.repo.api.YangIRSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.fs.FilesystemSchemaSourceCache;
import org.opendaylight.yangtools.yang.model.repo.spi.SoftSchemaSourceCache;
import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
-import org.opendaylight.yangtools.yang.parser.rfc7950.ir.IRSchemaSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.TextToIRTransformer;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
// for a consistent set of modules, as it skips the need to re-parse the text sources multiple times. It also
// helps establishing different sets of contexts, as they can share this pre-made cache.
repository.registerSchemaSourceListener(
- new SoftSchemaSourceCache<>(repository, IRSchemaSource.class));
+ new SoftSchemaSourceCache<>(repository, YangIRSchemaSource.class));
// Attach the filesystem cache, providing persistence capability, so that restarts do not require us to
// re-populate the cache. This also acts as a side-load capability, as anything pre-populated into that
return new LibraryModulesSchemas(ImmutableMap.of());
}
- if (moduleListNodeResult.getErrors().isEmpty() == false) {
+ if (!moduleListNodeResult.errors().isEmpty()) {
LOG.warn("{}: Unable to detect available schemas, get to {} failed, {}",
- deviceId, MODULES_STATE_MODULE_LIST, moduleListNodeResult.getErrors());
+ deviceId, MODULES_STATE_MODULE_LIST, moduleListNodeResult.errors());
return new LibraryModulesSchemas(ImmutableMap.of());
}
final Optional<DataContainerChild> modulesStateNode =
- findModulesStateNode(moduleListNodeResult.getResult());
+ findModulesStateNode(moduleListNodeResult.value());
if (modulesStateNode.isPresent()) {
final DataContainerChild node = modulesStateNode.get();
checkState(node instanceof ContainerNode, "Expecting container containing schemas, but was %s", node);
import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.rfc8528.model.api.SchemaMountConstants;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.RpcError;
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.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
// TODO check whether the model describing create subscription is present in schema
// Perhaps add a default schema context to support create-subscription if the model was not provided
// (same as what we do for base netconf operations in transformer)
- final ListenableFuture<DOMRpcResult> rpcResultListenableFuture = deviceRpc.invokeRpc(
+ final var rpcResultListenableFuture = deviceRpc.invokeRpc(
NetconfMessageTransformUtil.CREATE_SUBSCRIPTION_RPC_QNAME,
NetconfMessageTransformUtil.CREATE_SUBSCRIPTION_RPC_CONTENT);
}
private MountPointContext processSchemaMounts(final DOMRpcResult rpcResult, final MountPointContext emptyContext) {
- final Collection<? extends RpcError> errors = rpcResult.getErrors();
+ final var errors = rpcResult.errors();
if (!errors.isEmpty()) {
LOG.warn("{}: Schema-mounts acquisition resulted in errors {}", id, errors);
}
- final NormalizedNode schemaMounts = rpcResult.getResult();
+ final var schemaMounts = rpcResult.value();
if (schemaMounts == null) {
LOG.debug("{}: device does not define any schema mounts", id);
return emptyContext;
}
- if (!(schemaMounts instanceof ContainerNode)) {
- LOG.warn("{}: ignoring non-container schema mounts {}", id, schemaMounts);
- return emptyContext;
- }
- return DeviceMountPointContext.create(emptyContext, (ContainerNode) schemaMounts);
+ return DeviceMountPointContext.create(emptyContext, schemaMounts);
}
@Override
return EMPTY;
}
- if (!schemasNodeResult.getErrors().isEmpty()) {
+ if (!schemasNodeResult.errors().isEmpty()) {
LOG.warn("{}: Unable to detect available schemas, get to {} failed, {}",
- id, STATE_SCHEMAS_IDENTIFIER, schemasNodeResult.getErrors());
+ id, STATE_SCHEMAS_IDENTIFIER, schemasNodeResult.errors());
return EMPTY;
}
- final Optional<? extends NormalizedNode> optSchemasNode = findSchemasNode(schemasNodeResult.getResult(),
+ final Optional<? extends NormalizedNode> optSchemasNode = findSchemasNode(schemasNodeResult.value(),
schemaContext);
if (optSchemasNode.isEmpty()) {
LOG.warn("{}: Unable to detect available schemas, get to {} was empty", id, STATE_SCHEMAS_IDENTIFIER);
}
final ListenableFuture<DOMRpcResult> result = mergeFutures(lockImpl());
- Futures.addCallback(result, new FutureCallback<DOMRpcResult>() {
+ Futures.addCallback(result, new FutureCallback<>() {
@Override
public void onSuccess(final DOMRpcResult result) {
- final var errors = result.getErrors();
+ final var errors = result.errors();
if (errors.isEmpty()) {
LOG.debug("{}: Lock successful.", id);
return;
}
final ListenableFuture<DOMRpcResult> result = mergeFutures(unlockImpl());
- Futures.addCallback(result, new FutureCallback<DOMRpcResult>() {
+ Futures.addCallback(result, new FutureCallback<>() {
@Override
public void onSuccess(final DOMRpcResult result) {
final var errors = result.getErrors();
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return;
}
- if (result.getResult() != null) {
+ if (result.value() != null) {
reschedule();
} else {
- final var errors = result.getErrors();
+ final var errors = result.errors();
if (!errors.isEmpty()) {
LOG.warn("{}: Keepalive RPC failed with error: {}", id, errors);
reschedule();
}
@Override
- public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
+ public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final ContainerNode input) {
// FIXME: what happens if we disable keepalive and then invokeRpc() throws?
disableKeepalive();
return scheduleTimeout(delegate.invokeRpc(type, input));
import org.opendaylight.yangtools.concepts.NoOpListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* Invokes RPC by sending netconf message via listener. Also transforms result from NetconfMessage to
- * {@link NormalizedNode}.
+ * {@link ContainerNode}.
*/
public final class NetconfDeviceRpc implements Rpcs.Normalized {
private final RemoteDeviceCommunicator communicator;
- private final RpcTransformer<NormalizedNode, DOMRpcResult> transformer;
+ private final RpcTransformer<ContainerNode, DOMRpcResult> transformer;
private final EffectiveModelContext modelContext;
public NetconfDeviceRpc(final EffectiveModelContext modelContext, final RemoteDeviceCommunicator communicator,
- final RpcTransformer<NormalizedNode, DOMRpcResult> transformer) {
+ final RpcTransformer<ContainerNode, DOMRpcResult> transformer) {
this.modelContext = requireNonNull(modelContext);
this.communicator = communicator;
this.transformer = transformer;
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- public ListenableFuture<DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
+ public ListenableFuture<DOMRpcResult> invokeRpc(final QName type, final ContainerNode input) {
final ListenableFuture<RpcResult<NetconfMessage>> delegateFuture = communicator.sendRequest(
transformer.toRpcRequest(type, input), type);
}
protected static boolean isSuccess(final DOMRpcResult result) {
- return result.getErrors().isEmpty();
+ return result.errors().isEmpty();
}
protected void checkNotFinished() {
ErrorTag errorTag = ErrorTag.OPERATION_FAILED;
for (final DOMRpcResult domRpcResult : domRpcResults) {
- if (!domRpcResult.getErrors().isEmpty()) {
+ if (!domRpcResult.errors().isEmpty()) {
errorsEncouneterd = true;
- final RpcError error = domRpcResult.getErrors().iterator().next();
+ final RpcError error = domRpcResult.errors().iterator().next();
errType = error.getErrorType();
errSeverity = error.getSeverity();
LOG.trace("Lock is not allowed.");
return;
}
- final FutureCallback<DOMRpcResult> lockCandidateCallback = new FutureCallback<>() {
+ final var lockCandidateCallback = new FutureCallback<DOMRpcResult>() {
@Override
public void onSuccess(final DOMRpcResult result) {
if (isSuccess(result)) {
LOG.trace("Lock candidate successful");
}
} else {
- LOG.warn("{}: lock candidate invoked unsuccessfully: {}", id, result.getErrors());
+ LOG.warn("{}: lock candidate invoked unsuccessfully: {}", id, result.errors());
}
}
import org.xml.sax.SAXException;
public class NetconfMessageTransformer
- implements ActionTransformer, NotificationTransformer, RpcTransformer<NormalizedNode, DOMRpcResult> {
+ implements ActionTransformer, NotificationTransformer, RpcTransformer<ContainerNode, DOMRpcResult> {
private static final Logger LOG = LoggerFactory.getLogger(NetconfMessageTransformer.class);
private static final ImmutableSet<XMLNamespace> BASE_OR_NOTIFICATION_NS = ImmutableSet.of(
}
@Override
- public NetconfMessage toRpcRequest(final QName rpc, final NormalizedNode payload) {
+ public NetconfMessage toRpcRequest(final QName rpc, final ContainerNode payload) {
// In case no input for rpc is defined, we can simply construct the payload here
// Determine whether a base netconf operation is being invoked
checkNotNull(payload, "Transforming an rpc with input: %s, payload cannot be null", rpc);
- checkArgument(payload instanceof ContainerNode,
- "Transforming an rpc with input: %s, payload has to be a container, but was: %s", rpc, payload);
final DOMResult result = NetconfMessageTransformUtil.prepareDomResultForRpcRequest(rpc, counter);
try {
// If the schema context for netconf device does not contain model for base netconf operations,
// This way operations like lock/unlock are supported even if the source for base model was not provided
final EffectiveModelContext ctx = needToUseBaseCtx ? baseSchema.getEffectiveModelContext()
: mountContext.getEffectiveModelContext();
- NetconfMessageTransformUtil.writeNormalizedOperationInput((ContainerNode) payload, result, Absolute.of(rpc),
+ NetconfMessageTransformUtil.writeNormalizedOperationInput(payload, result, Absolute.of(rpc),
ctx);
} catch (final XMLStreamException | IOException | IllegalStateException e) {
throw new IllegalStateException("Unable to serialize input of " + rpc, e);
private final RemoteDeviceId id;
public NetconfRpcFutureCallback(final String prefix, final RemoteDeviceId id) {
- this.type = prefix;
+ type = prefix;
this.id = id;
}
@Override
public void onSuccess(final DOMRpcResult result) {
- if (result.getErrors().isEmpty()) {
+ if (result.errors().isEmpty()) {
LOG.trace("{}: {} invoked successfully", id, type);
} else {
onUnsuccess(result);
}
protected void onUnsuccess(final DOMRpcResult result) {
- LOG.warn("{}: {} invoked unsuccessfully: {}", id, type, result.getErrors());
+ LOG.warn("{}: {} invoked unsuccessfully: {}", id, type, result.errors());
}
@Override
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.opendaylight.mdsal.dom.api.DOMNotification;
-import org.opendaylight.mdsal.dom.api.DOMRpcResult;
-import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability.CapabilityOrigin;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaResolutionException;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
import org.xml.sax.SAXException;
public class NetconfDeviceTest extends AbstractTestModelTest {
-
private static final NetconfMessage NOTIFICATION;
- private static final ContainerNode COMPOSITE_NODE = mockClass(ContainerNode.class);
-
static {
try {
NOTIFICATION = new NetconfMessage(XmlUtil
}
}
- private static final DOMRpcResult RPC_RESULT = new DefaultDOMRpcResult(COMPOSITE_NODE);
-
public static final String TEST_NAMESPACE = "test:namespace";
public static final String TEST_MODULE = "test-module";
public static final String TEST_REVISION = "2013-07-22";
private static SchemaRepository getSchemaRepository() {
final SchemaRepository mock = mock(SchemaRepository.class);
- final SchemaSourceRepresentation mockRep = mock(SchemaSourceRepresentation.class);
+ final YangTextSchemaSource mockRep = mock(YangTextSchemaSource.class);
doReturn(Futures.immediateFuture(mockRep))
.when(mock).getSchemaSource(any(SourceIdentifier.class), eq(YangTextSchemaSource.class));
return mock;
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.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
@Test
public void testDeadlock() throws Exception {
// when rpc is successful, but transformer fails for some reason
- final RpcTransformer<NormalizedNode, DOMRpcResult> failingTransformer = mock(RpcTransformer.class);
+ final RpcTransformer<ContainerNode, DOMRpcResult> failingTransformer = mock(RpcTransformer.class);
final RemoteDeviceCommunicator communicatorMock = mock(RemoteDeviceCommunicator.class);
final NetconfMessage msg = null;
final RpcResult<NetconfMessage> result = RpcResultBuilder.success(msg).build();
public void testInvokeRpc() throws Exception {
ContainerNode input = createNode("urn:ietf:params:xml:ns:netconf:base:1.0", "2011-06-01", "filter");
final DOMRpcResult result = rpc.invokeRpc(type, input).get();
- assertEquals(expectedReply.getResult().getIdentifier(), result.getResult().getIdentifier());
+ assertEquals(expectedReply.value().getIdentifier(), result.value().getIdentifier());
assertEquals(resolveNode(expectedReply), resolveNode(result));
}
private static Node resolveNode(final DOMRpcResult result) {
- DataContainerChild value = ((ContainerNode) result.getResult())
- .findChildByArg(NetconfMessageTransformUtil.NETCONF_DATA_NODEID).get();
+ DataContainerChild value = result.value()
+ .findChildByArg(NetconfMessageTransformUtil.NETCONF_DATA_NODEID).orElseThrow();
Node node = ((DOMSourceAnyxmlNode)value).body().getNode();
assertNotNull(node);
return node;
final NetconfMessage msg = new NetconfMessage(doc);
final DOMRpcResult result = transformer.toRpcResult(RpcResultBuilder.success(msg).build(),
NetconfMessageTransformUtil.NETCONF_GET_CONFIG_QNAME);
- assertNotNull(result.getResult());
- final ContainerNode rpcReply = (ContainerNode) result.getResult();
+ assertNotNull(result.value());
+ final ContainerNode rpcReply = result.value();
assertEquals(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_QNAME, rpcReply.getIdentifier().getNodeType());
final Optional<?> dataOpt = rpcReply.findChildByArg(NetconfMessageTransformUtil.NETCONF_DATA_NODEID);
assertTrue(dataOpt.isPresent());
));
final DOMRpcResult compositeNodeRpcResult = transformer.toRpcResult(RpcResultBuilder.success(response).build(),
GET_SCHEMA_QNAME);
- assertTrue(compositeNodeRpcResult.getErrors().isEmpty());
- assertNotNull(compositeNodeRpcResult.getResult());
- final DOMSource schemaContent = ((DOMSourceAnyxmlNode) ((ContainerNode) compositeNodeRpcResult.getResult())
+ assertTrue(compositeNodeRpcResult.errors().isEmpty());
+ assertNotNull(compositeNodeRpcResult.value());
+ final DOMSource schemaContent = ((DOMSourceAnyxmlNode) compositeNodeRpcResult.value()
.body().iterator().next()).body();
assertThat(schemaContent.getNode().getTextContent(),
CoreMatchers.containsString("Random YANG SCHEMA"));
final NetconfMessageTransformer transformer = getTransformer(SCHEMA);
final DOMRpcResult compositeNodeRpcResult = transformer.toRpcResult(RpcResultBuilder.success(response).build(),
NETCONF_GET_CONFIG_QNAME);
- assertTrue(compositeNodeRpcResult.getErrors().isEmpty());
- assertNotNull(compositeNodeRpcResult.getResult());
+ assertTrue(compositeNodeRpcResult.errors().isEmpty());
+ assertNotNull(compositeNodeRpcResult.value());
final List<DataContainerChild> values = Lists.newArrayList(
NetconfRemoteSchemaYangSourceProvider
final MapEntryNode schemaNode =
Builders.mapEntryBuilder().withNodeIdentifier(identifierWithPredicates).withValue(values).build();
- final DOMSourceAnyxmlNode data = (DOMSourceAnyxmlNode) ((ContainerNode) compositeNodeRpcResult.getResult())
- .findChildByArg(toId(NETCONF_DATA_QNAME)).get();
+ final DOMSourceAnyxmlNode data = (DOMSourceAnyxmlNode) compositeNodeRpcResult.value()
+ .findChildByArg(toId(NETCONF_DATA_QNAME)).orElseThrow();
NormalizedNodeResult nodeResult =
NetconfUtil.transformDOMSourceToNormalizedNode(SCHEMA, data.body());
final DOMRpcResult compositeNodeRpcResult = netconfMessageTransformer.toRpcResult(
RpcResultBuilder.success(response).build(),
NETCONF_COMMIT_QNAME);
- assertTrue(compositeNodeRpcResult.getErrors().isEmpty());
- assertNull(compositeNodeRpcResult.getResult());
+ assertTrue(compositeNodeRpcResult.errors().isEmpty());
+ assertNull(compositeNodeRpcResult.value());
}
@Test
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
public WebInitializer(final WebServer webServer, final WebContextSecurer webContextSecurer,
final ServletSupport servletSupport, final Application webApp) throws ServletException {
- final var webContextBuilder = WebContext.builder().contextPath("yanglib").supportsSessions(true)
+ final var webContextBuilder = WebContext.builder().contextPath("/yanglib").supportsSessions(true)
.addServlet(ServletDetails.builder()
.servlet(servletSupport.createHttpServletBuilder(webApp).build())
.addUrlPattern("/*")
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.YangIRSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.api.YinSchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
import org.opendaylight.yangtools.yang.parser.impl.DefaultYangParserFactory;
-import org.opendaylight.yangtools.yang.parser.rfc7950.ir.IRSchemaSource;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class YangLibProviderTest {
potentialSources.add(
PotentialSchemaSource.create(new SourceIdentifier("asts-schema-source"),
- IRSchemaSource.class, PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
+ YangIRSchemaSource.class, PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
yangLibProvider.schemaSourceRegistered(potentialSources);
verifyNoMoreInteractions(dataBroker, writeTransaction);
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>10.0.3</version>
+ <version>11.0.3</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>4.0.2</version>
+ <version>5.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-artifacts</artifactId>
- <version>0.16.4</version>
+ <version>0.17.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>bundle-parent</artifactId>
- <version>6.0.3</version>
+ <version>7.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
package org.opendaylight.restconf.nb.rfc8040.rests.services.impl;
import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
@Deprecated(forRemoval = true, since = "4.0.0")
-abstract class AbstractOperationDataSchemaNode implements DataSchemaNode {
+abstract class AbstractOperationDataSchemaNode<D extends DeclaredStatement<QName>>
+ implements DataSchemaNode, EffectiveStatement<QName, D> {
+ @Override
+ public final D getDeclared() {
+ return null;
+ }
+
+ @Override
+ public final QName getQName() {
+ return argument();
+ }
+
@Override
public final Status getStatus() {
return Status.CURRENT;
import java.util.Collection;
import java.util.List;
-import java.util.Map;
import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.StatementOrigin;
+import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.FeatureEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
@Deprecated(forRemoval = true, since = "4.0.0")
abstract class AbstractOperationsModule implements Module, ModuleEffectiveStatement {
return StatementOrigin.CONTEXT;
}
- @Override
- public final <K, V, N extends IdentifierNamespace<K, V>> Optional<V> get(final Class<N> namespace,
- final K identifier) {
- return Optional.empty();
- }
-
- @Override
- public final <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAll(final Class<N> namespace) {
- return Map.of();
- }
-
@Override
public final Unqualified argument() {
return Unqualified.of(getName());
@Override
public final ModuleEffectiveStatement asEffectiveStatement() {
- throw new UnsupportedOperationException();
+ return this;
+ }
+
+ @Override
+ public final Optional<ExtensionEffectiveStatement> findExtension(final QName qname) {
+ return Optional.empty();
+ }
+
+ @Override
+ public final Optional<FeatureEffectiveStatement> findFeature(final QName qname) {
+ return Optional.empty();
}
@Override
- public final ConformanceType conformance() {
- throw new UnsupportedOperationException();
+ public final Optional<IdentityEffectiveStatement> findIdentity(final QName qname) {
+ return Optional.empty();
+ }
+
+ @Override
+ public final Optional<SubmoduleEffectiveStatement> findSubmodule(final Unqualified submoduleName) {
+ return Optional.empty();
}
}
import com.google.common.collect.Maps;
import java.util.Collection;
+import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.util.CollectionWrappers;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
@Deprecated(forRemoval = true, since = "4.0.0")
-final class OperationsContainerSchemaNode extends AbstractOperationDataSchemaNode implements ContainerSchemaNode {
+final class OperationsContainerSchemaNode extends AbstractOperationDataSchemaNode<ContainerStatement>
+ implements ContainerSchemaNode, ContainerEffectiveStatement {
// There is no need to intern this nor add a revision, as we are providing the corresponding context anyway
static final @NonNull QName QNAME = QName.create(OperationsRestconfModule.NAMESPACE, "operations");
}
@Override
- public QName getQName() {
+ public QName argument() {
return QNAME;
}
+ @Override
+ public List<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+ return CollectionWrappers.wrapAsList(children.values());
+ }
+
@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public Collection<DataSchemaNode> getChildNodes() {
return (Collection) children.values();
}
+ @Override
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public Collection<DataTreeEffectiveStatement<?>> dataTreeNodes() {
+ return (Collection) children.values();
+ }
+
+ @Override
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public Collection<SchemaTreeEffectiveStatement<?>> schemaTreeNodes() {
+ return (Collection) children.values();
+ }
+
+ @Override
+ public Optional<DataTreeEffectiveStatement<?>> findDataTreeNode(final QName qname) {
+ return Optional.ofNullable(children.get(requireNonNull(qname)));
+ }
+
+ @Override
+ public @NonNull Optional<SchemaTreeEffectiveStatement<?>> findSchemaTreeNode(final QName qname) {
+ return Optional.ofNullable(children.get(requireNonNull(qname)));
+ }
+
@Override
public DataSchemaNode dataChildByName(final QName name) {
return children.get(requireNonNull(name));
@Override
public ContainerEffectiveStatement asEffectiveStatement() {
- throw new UnsupportedOperationException();
+ return this;
}
}
import java.util.Collection;
import java.util.List;
+import java.util.Map.Entry;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
@Deprecated(forRemoval = true, since = "4.0.0")
final class OperationsImportedModule extends AbstractOperationsModule {
public List<EffectiveStatement<?, ?>> effectiveSubstatements() {
return List.of();
}
+
+ @Override
+ public ConformanceType conformance() {
+ return ConformanceType.IMPORT;
+ }
+
+ @Override
+ public Collection<DataTreeEffectiveStatement<?>> dataTreeNodes() {
+ return List.of();
+ }
+
+ @Override
+ public Optional<DataTreeEffectiveStatement<?>> findDataTreeNode(final QName qname) {
+ return Optional.empty();
+ }
+
+ @Override
+ public Collection<SchemaTreeEffectiveStatement<?>> schemaTreeNodes() {
+ return List.of();
+ }
+
+ @Override
+ public Optional<SchemaTreeEffectiveStatement<?>> findSchemaTreeNode(final QName qname) {
+ return Optional.empty();
+ }
+
+ @Override
+ public Optional<ModuleEffectiveStatement> findReachableModule(final String prefix) {
+ return Optional.empty();
+ }
+
+ @Override
+ public Collection<Entry<String, ModuleEffectiveStatement>> reachableModules() {
+ return List.of();
+ }
+
+ @Override
+ public Optional<String> findNamespacePrefix(final QNameModule namespace) {
+ return Optional.empty();
+ }
+
+ @Override
+ public Collection<Entry<QNameModule, String>> namespacePrefixes() {
+ return List.of();
+ }
}
package org.opendaylight.restconf.nb.rfc8040.rests.services.impl;
import java.util.Collection;
+import java.util.List;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.LeafStatement;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
@Deprecated(forRemoval = true, since = "4.0.0")
-final class OperationsLeafSchemaNode extends AbstractOperationDataSchemaNode implements LeafSchemaNode {
+final class OperationsLeafSchemaNode extends AbstractOperationDataSchemaNode<LeafStatement>
+ implements LeafSchemaNode, LeafEffectiveStatement {
private final QName qname;
OperationsLeafSchemaNode(final RpcDefinition rpc) {
}
@Override
- public QName getQName() {
+ public QName argument() {
return qname;
}
@Override
public LeafEffectiveStatement asEffectiveStatement() {
- throw new UnsupportedOperationException();
+ return this;
+ }
+
+ @Override
+ public List<EffectiveStatement<?, ?>> effectiveSubstatements() {
+ // FIXME: a 'type empty; mandatory true;' substatements, actually
+ return List.of();
}
}
import java.util.Collection;
import java.util.List;
+import java.util.Map.Entry;
+import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
@Deprecated(forRemoval = true, since = "4.0.0")
final class OperationsRestconfModule extends AbstractOperationsModule {
@Override
public DataSchemaNode dataChildByName(final QName name) {
- return operations.getQName().equals(requireNonNull(name)) ? operations : null;
+ return name.equals(operations.getQName()) ? operations : null;
}
@Override
public List<EffectiveStatement<?, ?>> effectiveSubstatements() {
- // This is not accurate, but works for now
+ return List.of(operations);
+ }
+
+ @Override
+ public ConformanceType conformance() {
+ return ConformanceType.IMPLEMENT;
+ }
+
+ @Override
+ public Optional<DataTreeEffectiveStatement<?>> findDataTreeNode(final QName qname) {
+ return qname.equals(operations.getQName()) ? Optional.of(operations) : Optional.empty();
+ }
+
+ @Override
+ public Optional<SchemaTreeEffectiveStatement<?>> findSchemaTreeNode(final QName qname) {
+ return qname.equals(operations.getQName()) ? Optional.of(operations) : Optional.empty();
+ }
+
+ @Override
+ public Collection<DataTreeEffectiveStatement<?>> dataTreeNodes() {
+ return List.of(operations);
+ }
+
+ @Override
+ public Collection<SchemaTreeEffectiveStatement<?>> schemaTreeNodes() {
+ return List.of(operations);
+ }
+
+ @Override
+ public Optional<ModuleEffectiveStatement> findReachableModule(final String prefix) {
+ return Optional.empty();
+ }
+
+ @Override
+ public Collection<Entry<String, ModuleEffectiveStatement>> reachableModules() {
+ return List.of();
+ }
+
+ @Override
+ public Optional<String> findNamespacePrefix(final QNameModule namespace) {
+ return Optional.empty();
+ }
+
+ @Override
+ public Collection<Entry<QNameModule, String>> namespacePrefixes() {
return List.of();
}
}
ErrorType.RPC, ErrorTag.OPERATION_NOT_SUPPORTED));
}
} else {
- future = invokeRpc(payload.getData(), rpcName, rpcService);
+ future = invokeRpc((ContainerNode)payload.getData(), rpcName, rpcService);
}
} else {
future = invokeRpc(payload.getData(), rpcName, mountPoint);
@VisibleForTesting
static ListenableFuture<? extends DOMRpcResult> invokeRpc(final NormalizedNode data, final QName rpc,
final DOMMountPoint mountPoint) {
- return invokeRpc(data, rpc, mountPoint.getService(DOMRpcService.class).orElseThrow(() -> {
+ return invokeRpc((ContainerNode) data, rpc, mountPoint.getService(DOMRpcService.class).orElseThrow(() -> {
final String errmsg = "RPC service is missing.";
LOG.debug(errmsg);
return new RestconfDocumentedException(errmsg);
* @return {@link DOMRpcResult}
*/
@VisibleForTesting
- static ListenableFuture<? extends DOMRpcResult> invokeRpc(final NormalizedNode data, final QName rpc,
+ static ListenableFuture<? extends DOMRpcResult> invokeRpc(final ContainerNode data, final QName rpc,
final DOMRpcService rpcService) {
return Futures.catching(rpcService.invokeRpc(rpc, nonnullInput(rpc, data)),
DOMRpcException.class,
MoreExecutors.directExecutor());
}
- private static @NonNull NormalizedNode nonnullInput(final QName type, final NormalizedNode input) {
+ private static @NonNull ContainerNode nonnullInput(final QName type, final ContainerNode input) {
return input != null ? input
: ImmutableNodes.containerNode(YangConstants.operationInputQName(type.getModule()));
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
public WebInitializer(final WebServer webServer, final WebContextSecurer webContextSecurer,
final ServletSupport servletSupport, final Application webApp) throws ServletException {
var webContextBuilder = WebContext.builder()
- .contextPath("apidoc")
+ .contextPath("/apidoc")
.supportsSessions(true)
.addServlet(ServletDetails.builder()
.servlet(servletSupport.createHttpServletBuilder(webApp).build())
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>11.0.2</version>
+ <version>12.0.1</version>
<relativePath/>
</parent>
Code Review / netconf.git / commitdiff