final IpAddress yangIp;
if (ipAddress instanceof Inet4Address) {
- yangIp = new IpAddress(IetfInetUtil.INSTANCE.ipv4AddressFor(ipAddress));
+ yangIp = new IpAddress(IetfInetUtil.ipv4AddressFor(ipAddress));
} else {
checkArgument(ipAddress instanceof Inet6Address);
- yangIp = new IpAddress(IetfInetUtil.INSTANCE.ipv6AddressFor(ipAddress));
+ yangIp = new IpAddress(IetfInetUtil.ipv6AddressFor(ipAddress));
}
return new ContextKey(yangIp, new PortNumber(Uint16.valueOf(inetSocketAddr.getPort())));
}
private static InetSocketAddress getInetAddress(final String bindingAddress, final int portNumber) {
final var ipAddress = IetfInetUtil.ipAddressFor(bindingAddress);
- return new InetSocketAddress(IetfInetUtil.INSTANCE.inetAddressFor(ipAddress), portNumber);
+ return new InetSocketAddress(IetfInetUtil.inetAddressFor(ipAddress), portNumber);
}
}
}
private static InetSocketAddress getInetAddress(final String bindingAddress, final int portNumber) {
- final var inetAd = IetfInetUtil.INSTANCE.inetAddressFor(IetfInetUtil.ipAddressFor(bindingAddress));
+ final var inetAd = IetfInetUtil.inetAddressFor(IetfInetUtil.ipAddressFor(bindingAddress));
return new InetSocketAddress(inetAd, portNumber);
}
}
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-topology</artifactId>
</dependency>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.guicedee.services</groupId>
<artifactId>javax.inject</artifactId>
import org.opendaylight.netconf.topology.singleton.messages.CreateInitialMasterActorData;
import org.opendaylight.netconf.topology.spi.NetconfDeviceTopologyAdapter;
import org.opendaylight.netconf.topology.spi.NetconfNodeUtils;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.slf4j.Logger;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
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;
final var resources = resourceManager.getSchemaResources(TEST_DEFAULT_SUBDIR, "test");
resources.getSchemaRegistry().registerSchemaSource(
- id -> Futures.immediateFuture(YangTextSchemaSource.delegateForByteSource(id,
- topModuleInfo.getYangTextByteSource())),
+ id -> Futures.immediateFuture(YangTextSchemaSource.delegateForCharSource(id,
+ topModuleInfo.getYangTextCharSource())),
PotentialSchemaSource.create(new SourceIdentifier(TOP_MODULE_NAME,
topModuleInfo.getName().getRevision().map(Revision::toString).orElse(null)),
YangTextSchemaSource.class, 1));
final var masterSalFacade = masterSalFacadeFuture.get(5, TimeUnit.SECONDS);
masterSalFacade.onDeviceConnected(new NetconfDeviceSchema(NetconfDeviceCapabilities.empty(),
- new EmptyMountPointContext(deviceSchemaContext)),
+ MountPointContext.of(deviceSchemaContext)),
NetconfSessionPreferences.fromStrings(List.of(CapabilityURN.CANDIDATE)),
new RemoteDeviceServices(deviceRpcService, null));
final var masterSalFacade = masterSalFacadeFuture.get(5, TimeUnit.SECONDS);
masterSalFacade.onDeviceConnected(
- new NetconfDeviceSchema(NetconfDeviceCapabilities.empty(), new EmptyMountPointContext(deviceSchemaContext)),
+ new NetconfDeviceSchema(NetconfDeviceCapabilities.empty(), MountPointContext.of(deviceSchemaContext)),
NetconfSessionPreferences.fromStrings(List.of(CapabilityURN.CANDIDATE)),
new RemoteDeviceServices(deviceRpcService, null));
*/
package org.opendaylight.netconf.topology.singleton.impl;
-import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.startsWith;
import akka.testkit.javadsl.TestKit;
import akka.util.Timeout;
import com.google.common.collect.ImmutableList;
-import com.google.common.io.ByteSource;
+import com.google.common.io.CharSource;
import com.google.common.net.InetAddresses;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
-import java.io.InputStream;
import java.net.InetSocketAddress;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import java.util.Scanner;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import org.junit.After;
final ProxyYangTextSourceProvider proxyYangProvider =
new ProxyYangTextSourceProvider(masterRef, system.dispatcher(), TIMEOUT);
- final YangTextSchemaSource yangTextSchemaSource = YangTextSchemaSource.delegateForByteSource(sourceIdentifier,
- ByteSource.wrap("YANG".getBytes(UTF_8)));
+ final YangTextSchemaSource yangTextSchemaSource = YangTextSchemaSource.delegateForCharSource(sourceIdentifier,
+ CharSource.wrap("YANG"));
// Test success.
final YangTextSchemaSourceSerializationProxy success = Await.result(resolvedSchemaFuture, TIMEOUT.duration());
assertEquals(sourceIdentifier, success.getRepresentation().getIdentifier());
- assertEquals("YANG", convertStreamToString(success.getRepresentation().openStream()));
+ assertEquals("YANG", success.getRepresentation().read());
// Test missing source failure.
private static PotentialSchemaSource<?> withSourceId(final SourceIdentifier identifier) {
return argThat(argument -> identifier.equals(argument.getSourceIdentifier()));
}
-
- private static String convertStreamToString(final InputStream is) {
- try (Scanner scanner = new Scanner(is)) {
- return scanner.useDelimiter("\\A").hasNext() ? scanner.next() : "";
- }
- }
}
*/
package org.opendaylight.netconf.topology.singleton.impl;
-import static java.nio.charset.StandardCharsets.UTF_8;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.after;
import akka.testkit.javadsl.TestKit;
import akka.util.Timeout;
import com.google.common.collect.Iterables;
-import com.google.common.io.ByteSource;
+import com.google.common.io.CharSource;
import com.google.common.util.concurrent.Futures;
import com.typesafe.config.ConfigFactory;
import java.net.InetSocketAddress;
SOURCE_IDENTIFIERS.stream().map(
sourceId -> masterSchemaRepository.registerSchemaSource(
- id -> Futures.immediateFuture(YangTextSchemaSource.delegateForByteSource(id,
- ByteSource.wrap(yangTemplate.replaceAll("ID", id.name().getLocalName()).getBytes(UTF_8)))),
+ id -> Futures.immediateFuture(YangTextSchemaSource.delegateForCharSource(id,
+ CharSource.wrap(yangTemplate.replaceAll("ID", id.name().getLocalName())))),
PotentialSchemaSource.create(sourceId, YangTextSchemaSource.class, 1)))
.collect(Collectors.toList());
final var host = node.requireHost();
final int port = node.requirePort().getValue().toJava();
final var ipAddress = host.getIpAddress();
- return ipAddress != null ? new InetSocketAddress(IetfInetUtil.INSTANCE.inetAddressFor(ipAddress), port)
+ return ipAddress != null ? new InetSocketAddress(IetfInetUtil.inetAddressFor(ipAddress), port)
: new InetSocketAddress(host.getDomainName().getValue(), port);
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
-->
<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.17,1)">odl-aaa-shiro</feature>
+ <feature version="[0.18,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="[12,13)">odl-netty-4</feature>
- <feature version="[11,12)">odl-mdsal-model-rfc8525</feature>
+ <feature version="[13,14)">odl-netty-4</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc8525</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="[7,8)">odl-controller-exp-netty-config</feature>
+ <feature version="[8,9)">odl-controller-exp-netty-config</feature>
</feature>
</features>
-->
<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="[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 version="[12,13)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[0.18,1)">odl-aaa-encryption-service</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="[7,8)">odl-controller-exp-netty-config</feature>
+ <feature version="[8,9)">odl-controller-exp-netty-config</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc5277" version="${project.version}">
- <feature version="[11,12)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc6022" version="${project.version}">
- <feature version="[11,12)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc6241" version="${project.version}">
- <feature version="[11,12)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc8040" version="${project.version}">
- <feature version="[11,12)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc8341" version="${project.version}">
- <feature version="[11,12)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc8526" version="${project.version}">
- <feature version="[11,12)">odl-mdsal-model-rfc8342</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc8342</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-model-rfc8639" version="${project.version}">
- <feature version="[11,12)">odl-mdsal-model-rfc8040</feature>
- <feature version="[11,12)">odl-mdsal-model-rfc8343</feature>
- <feature version="[11,12)">odl-mdsal-model-rfc8528</feature>
- <feature version="[11,12)">odl-mdsal-model-rfc8529</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc8040</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc8343</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc8528</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc8529</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="[12,13)">odl-netty-4</feature>
- <feature version="[0.17,1)">odl-aaa-encryption-service</feature>
+ <feature version="[13,14)">odl-netty-4</feature>
+ <feature version="[0.18,1)">odl-aaa-encryption-service</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-transport-api" version="${project.version}">
- <feature version="[12,13)">odl-netty-4</feature>
- <feature version="[10,11)">odl-yangtools-common</feature>
+ <feature version="[13,14)">odl-netty-4</feature>
+ <feature version="[11,12)">odl-yangtools-common</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-util" version="${project.version}">
- <feature version="[10,11)">odl-yangtools-codec</feature>
+ <feature version="[11,12)">odl-yangtools-codec</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="[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 version="[13,14)">odl-karaf-feat-jetty</feature>
+ <feature version="[11,12)">odl-yangtools-export</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc8040</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc8525</feature>
+ <feature version="[8,9)">odl-mdsal-broker</feature>
+ <feature version="[0.18,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="[11,12)">odl-mdsal-model-rfc8072</feature>
- <feature version="[7,8)">odl-controller-exp-netty-config</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc8072</feature>
+ <feature version="[8,9)">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>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-restconf-openapi" version="${project.version}">
- <feature version="[12,13)">odl-jackson-2</feature>
+ <feature version="[13,14)">odl-jackson-2</feature>
</feature>
</features>
-->
<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="[12,13)">odl-karaf-feat-jetty</feature>
- <feature version="[11,12)">odl-mdsal-model-rfc8525</feature>
+ <feature version="[13,14)">odl-karaf-feat-jetty</feature>
+ <feature version="[12,13)">odl-mdsal-model-rfc8525</feature>
<configfile finalname="etc/opendaylight/datastore/initial/config/yanglib-config.xml">
mvn:org.opendaylight.netconf/yanglib/${project.version}/xml/config
</configfile>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf-dist-static</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.netconf</groupId>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>5.0.5</version>
+ <version>6.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>7.0.8</version>
+ <version>8.0.0-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<packaging>bundle</packaging>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.eclipse.jdt</groupId>
+ <artifactId>org.eclipse.jdt.annotation</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>threadpool-config-api</artifactId>
<dependencies>
<!-- compile dependencies -->
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
</properties>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>org.codehaus.janino</groupId>
<artifactId>janino</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
- <artifactId>rfc6991</artifactId>
+ <artifactId>rfc6991-ietf-inet-types</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.nio.channels.AsynchronousChannelGroup;
-import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
final String moduleContent;
try {
- moduleContent = consumer.getSchemaSource(sourceId, YangTextSchemaSource.class).get()
- .asCharSource(StandardCharsets.UTF_8).read();
+ moduleContent = consumer.getSchemaSource(sourceId, YangTextSchemaSource.class).get().read();
} catch (ExecutionException | InterruptedException | IOException e) {
throw new IllegalStateException(
"Cannot retrieve schema source for module " + sourceId + " from schema repository", e);
import com.google.common.base.Joiner;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlTransient;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.Session;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netconf.monitoring.rev220718.Session1;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
final class MonitoringSession {
public String getTransport() {
try {
final QName qualifiedName = (QName) managementSession.getTransport().implementedInterface()
- .getField(BindingMapping.QNAME_STATIC_FIELD_NAME).get(null);
+ .getField(Naming.QNAME_STATIC_FIELD_NAME).get(null);
// Add extension prefix if transport type is from extension yang module
if (qualifiedName.getNamespace().toString().equals(MonitoringConstants.EXTENSION_NAMESPACE)) {
return Joiner.on(':').join(MonitoringConstants.EXTENSION_NAMESPACE_PREFIX,
public synchronized ListenableFuture<? extends T> getSource(final SourceIdentifier sourceIdentifier) {
final YangModuleInfo yangModuleInfo = cachedSchemas.get(sourceIdentifier);
if (yangModuleInfo != null) {
- final YangTextSchemaSource yangTextSchemaSource = YangTextSchemaSource.delegateForByteSource(
- sourceIdentifier, yangModuleInfo.getYangTextByteSource());
+ final YangTextSchemaSource yangTextSchemaSource = YangTextSchemaSource.delegateForCharSource(
+ sourceIdentifier, yangModuleInfo.getYangTextCharSource());
return Futures.immediateFuture(representation.cast(yangTextSchemaSource));
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
import com.google.common.util.concurrent.MoreExecutors;
import java.io.File;
import java.io.IOException;
-import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
final var yangTextSchemaFuture = schemaRepository.getSchemaSource(sourceId, YangTextSchemaSource.class);
try {
final var yangTextSchemaSource = yangTextSchemaFuture.get();
- return yangTextSchemaSource.asCharSource(StandardCharsets.UTF_8).read();
+ return yangTextSchemaSource.read();
} catch (ExecutionException e) {
if (e.getCause() instanceof MissingSchemaSourceException) {
throw new NotFoundException("Schema source " + sourceId + " not found", e);
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>11.0.11</version>
+ <version>12.0.0-SNAPSHOT</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>5.0.5</version>
+ <version>6.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-artifacts</artifactId>
- <version>0.17.10</version>
+ <version>0.18.0-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>bundle-parent</artifactId>
- <version>7.0.8</version>
+ <version>8.0.0-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>concepts</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc7952-data-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc7952-data-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc8528-data-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc8528-data-util</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>rfc8528-model-api</artifactId>
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
-import java.io.ByteArrayInputStream;
-import java.io.InputStream;
+import java.io.Reader;
+import java.io.StringReader;
import java.util.Optional;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
*/
public final class CachedYangTextSchemaSource extends YangTextSchemaSource {
private final RemoteDeviceId id;
- private final byte[] schemaBytes;
+ private final String schemaString;
private final String symbolicName;
public CachedYangTextSchemaSource(final RemoteDeviceId id, final SourceIdentifier sourceIdentifier,
- final String symbolicName, final byte[] schemaBytes) {
+ final String symbolicName, final String schemaString) {
super(sourceIdentifier);
this.symbolicName = requireNonNull(symbolicName);
this.id = requireNonNull(id);
- this.schemaBytes = schemaBytes.clone();
+ this.schemaString = requireNonNull(schemaString);
}
@Override
}
@Override
- public InputStream openStream() {
- return new ByteArrayInputStream(schemaBytes);
+ public Reader openStream() {
+ return new StringReader(schemaString);
}
@Override
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContextFactory;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointIdentifier;
import org.opendaylight.yangtools.rfc8528.model.api.SchemaMountConstants;
+import org.opendaylight.yangtools.yang.common.MountPointLabel;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContextFactory;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.spi.AbstractEffectiveModelContextProvider;
private static final NodeIdentifier PARENT_REFERENCE = NodeIdentifier.create(
QName.create(SchemaMountConstants.RFC8528_MODULE, "parent-reference").intern());
- private final ImmutableMap<MountPointIdentifier, NetconfMountPointContextFactory> mountPoints;
+ private final ImmutableMap<MountPointLabel, NetconfMountPointContextFactory> mountPoints;
private DeviceMountPointContext(final EffectiveModelContext schemaContext,
- final Map<MountPointIdentifier, NetconfMountPointContextFactory> mountPoints) {
+ final Map<MountPointLabel, NetconfMountPointContextFactory> mountPoints) {
super(schemaContext);
this.mountPoints = ImmutableMap.copyOf(mountPoints);
}
final DataContainerChild mountPoint = optMountPoint.orElseThrow();
checkArgument(mountPoint instanceof MapNode, "mount-point list %s is not a MapNode", mountPoint);
- final Map<MountPointIdentifier, NetconfMountPointContextFactory> mountPoints = new HashMap<>();
+ final Map<MountPointLabel, NetconfMountPointContextFactory> mountPoints = new HashMap<>();
for (MapEntryNode entry : ((MapNode) mountPoint).body()) {
final String moduleName = entry.findChildByArg(MODULE).map(mod -> {
checkArgument(mod instanceof LeafNode, "Unexpected module leaf %s", mod);
checkArgument(it.hasNext(), "Failed to find a module named %s", moduleName);
final QNameModule module = it.next().getQNameModule();
- final MountPointIdentifier mountId = MountPointIdentifier.of(QName.create(module,
+ final MountPointLabel mountId = new MountPointLabel(QName.create(module,
entry.findChildByArg(LABEL).map(lbl -> {
checkArgument(lbl instanceof LeafNode, "Unexpected label leaf %s", lbl);
final Object value = lbl.body();
}
@Override
- public Optional<MountPointContextFactory> findMountPoint(@NonNull final MountPointIdentifier label) {
+ public Optional<MountPointContextFactory> findMountPoint(@NonNull final MountPointLabel label) {
return Optional.ofNullable(mountPoints.get(requireNonNull(label)));
}
}
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizationResult;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
}
private static Optional<NormalizedNode> readJson(final InputStream in) {
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final JsonParserStream jsonParser = JsonParserStream.create(writer, JSON_CODECS);
jsonParser.parse(reader);
- return resultHolder.isFinished() ? Optional.of(resultHolder.getResult()) : Optional.empty();
+ final NormalizationResult result = resultHolder.result();
+ return result == null ? Optional.empty() : Optional.of(result.data());
}
private static Optional<NormalizedNode> readXml(final InputStream in) {
}
}
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final XmlParserStream xmlParser = XmlParserStream.create(writer, MODULES_STATE_INFERENCE);
xmlParser.traverse(new DOMSource(doc.getDocumentElement()));
- return Optional.of(resultHolder.getResult());
+ return Optional.of(resultHolder.getResult().data());
} catch (XMLStreamException | URISyntaxException | IOException | SAXException e) {
LOG.warn("Unable to parse yang library xml content", e);
}
import com.google.common.util.concurrent.ListenableFuture;
import java.io.IOException;
import java.net.URL;
+import java.nio.charset.StandardCharsets;
import java.util.Map;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
"Unable to download remote schema for " + sourceIdentifier + " from " + url, e));
}
- final var yangSource = new CachedYangTextSchemaSource(id, sourceIdentifier, url.toString(), schemaContent);
+ final var yangSource = new CachedYangTextSchemaSource(id, sourceIdentifier, url.toString(),
+ new String(schemaContent, StandardCharsets.UTF_8));
LOG.debug("Source {} downloaded from a yang library's url {}", sourceIdentifier, url);
return Futures.immediateFuture(yangSource);
}
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-import java.nio.charset.StandardCharsets;
import java.util.Optional;
import javax.xml.transform.dom.DOMSource;
import org.eclipse.jdt.annotation.NonNull;
id + ": Unexpected response to get-schema, schema not present in message for: "
+ sourceIdentifier));
LOG.debug("{}: YANG Schema successfully retrieved for {}:{}", id, moduleName, revision);
- return new CachedYangTextSchemaSource(id, sourceIdentifier, moduleName,
- schemaString.getBytes(StandardCharsets.UTF_8));
+ return new CachedYangTextSchemaSource(id, sourceIdentifier, moduleName, schemaString);
}
LOG.warn("{}: YANG schema was not successfully retrieved for {}. Errors: {}", id, sourceIdentifier,
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.connection.oper.unavailable.capabilities.UnavailableCapability;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev230430.connection.oper.unavailable.capabilities.UnavailableCapability.FailureReason;
import org.opendaylight.yangtools.concepts.Registration;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
-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.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
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;
private ListenableFuture<@NonNull MountPointContext> createMountPointContext(
final EffectiveModelContext schemaContext, final BaseSchema baseSchema,
final NetconfDeviceCommunicator listener) {
- final MountPointContext emptyContext = new EmptyMountPointContext(schemaContext);
+ final MountPointContext emptyContext = MountPointContext.of(schemaContext);
if (schemaContext.findModule(SchemaMountConstants.RFC8528_MODULE).isEmpty()) {
return Futures.immediateFuture(emptyContext);
}
import static java.util.Objects.requireNonNull;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
package org.opendaylight.netconf.client.mdsal;
import java.util.Map;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointChild;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContextFactory;
-import org.opendaylight.yangtools.rfc8528.data.api.YangLibraryConstants.ContainerName;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointChild;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContextFactory;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.parser.api.YangParserException;
// TODO: this should really come from mdsal-yanglib-rfc8525
final class NetconfMountPointContextFactory implements MountPointContextFactory {
- private final MountPointContext mountPoint;
+ private final @NonNull MountPointContext mountPoint;
NetconfMountPointContextFactory(final EffectiveModelContext schemaContext) {
- mountPoint = new EmptyMountPointContext(schemaContext);
+ mountPoint = MountPointContext.of(schemaContext);
}
@Override
public MountPointContext createContext(final Map<ContainerName, MountPointChild> libraryContainers,
- final MountPointChild schemaMounts) throws YangParserException {
+ final MountPointChild schemaMounts) {
return mountPoint;
}
}
final NormalizedNode dataNode;
try {
- dataNode = NormalizedDataUtil.transformDOMSourceToNormalizedNode(schemaContext, filteredBody).getResult();
+ dataNode = NormalizedDataUtil.transformDOMSourceToNormalizedNode(schemaContext, filteredBody).getResult()
+ .data();
} catch (XMLStreamException | URISyntaxException | IOException | SAXException e) {
LOG.warn("Failed to transform {}", rpcResult, e);
return Optional.empty();
public @NonNull Host host() {
final var addr = address.getAddress();
- return addr != null ? new Host(IetfInetUtil.INSTANCE.ipAddressFor(addr))
+ return addr != null ? new Host(IetfInetUtil.ipAddressFor(addr))
: new Host(new DomainName(address.getHostString()));
}
}
import com.google.common.collect.Maps;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
public final class BaseSchema implements EffectiveModelContextProvider, Immutable {
private final @NonNull ImmutableMap<QName, ? extends RpcDefinition> mappedRpcs;
- private final @NonNull EmptyMountPointContext mountContext;
+ private final @NonNull MountPointContext mountContext;
BaseSchema(final EffectiveModelContext context) {
- mountContext = new EmptyMountPointContext(context);
+ mountContext = MountPointContext.of(context);
mappedRpcs = Maps.uniqueIndex(context.getOperations(), RpcDefinition::getQName);
}
return mappedRpcs;
}
- public @NonNull EmptyMountPointContext getMountPointContext() {
+ public @NonNull MountPointContext getMountPointContext() {
return mountContext;
}
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Rpcs;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.copy.config.input.target.ConfigTarget;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.get.config.input.source.ConfigSource;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.common.Empty;
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.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
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;
*/
package org.opendaylight.netconf.client.mdsal.impl;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.netconf.common.mdsal.NormalizedDataUtil.NETCONF_DATA_QNAME;
import static org.opendaylight.netconf.common.mdsal.NormalizedDataUtil.NETCONF_QNAME;
import java.time.format.DateTimeParseException;
import java.util.ArrayDeque;
import java.util.Collection;
-import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.CreateSubscriptionInput;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfCapabilityChange;
-import org.opendaylight.yangtools.rfc7952.data.api.NormalizedMetadata;
-import org.opendaylight.yangtools.rfc7952.data.util.ImmutableNormalizedMetadata;
-import org.opendaylight.yangtools.rfc7952.data.util.ImmutableNormalizedMetadata.Builder;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangConstants;
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.NormalizedMetadata;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.YangInstanceIdentifierWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XMLStreamNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedMetadata;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaOrderedNormalizedNodeWriter;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext.PathMixin;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
// Blank document used for creation of new DOM nodes
private static final Document BLANK_DOCUMENT = XmlUtil.newDocument();
- private NetconfMessageTransformUtil() {
-
- }
-
public static final @NonNull QName IETF_NETCONF_MONITORING =
QName.create(NetconfState.QNAME, "ietf-netconf-monitoring").intern();
public static final @NonNull QName GET_DATA_QNAME = QName.create(IETF_NETCONF_MONITORING, "data").intern();
public static final @NonNull AnyxmlNode<?> EMPTY_FILTER = buildFilterStructure(getNetconfFilterElement());
+ private NetconfMessageTransformUtil() {
+ // Hidden on purpose
+ }
+
/**
* Creation of the subtree filter structure using {@link YangInstanceIdentifier} path.
*
// into xml
final var parentPath = dataPath.isEmpty() ? dataPath : dataPath.coerceParent();
- var result = new NormalizedNodeResult();
+ var result = new NormalizationResultHolder();
try (var streamWriter = ImmutableNormalizedNodeStreamWriter.from(result)) {
try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, ctx, parentPath);
var nnWriter = NormalizedNodeWriter.forStreamWriter(streamWriter)) {
nnWriter.write(lastChildOverride.orElseThrow());
}
}
- NormalizedDataUtil.writeNormalizedNode(result.getResult(), metadata, new DOMResult(element), ctx, null);
+ NormalizedDataUtil.writeNormalizedNode(result.getResult().data(), metadata, new DOMResult(element), ctx,
+ null);
} else {
NormalizedDataUtil.writeNormalizedNode(dataPath, metadata, new DOMResult(element), ctx, null);
}
}
private static NormalizedMetadata leafMetadata(final YangInstanceIdentifier path, final EffectiveOperation oper) {
- final List<PathArgument> args = path.getPathArguments();
- final Deque<Builder> builders = new ArrayDeque<>(args.size());
+ record BuilderAndArg(ImmutableNormalizedMetadata.Builder builder, PathArgument arg) {
+ BuilderAndArg {
+ requireNonNull(builder);
+ requireNonNull(arg);
+ }
+ }
+
+ final var args = path.getPathArguments();
+ final var builders = new ArrayDeque<BuilderAndArg>(args.size());
// Step one: open builders
for (PathArgument arg : args) {
- builders.push(ImmutableNormalizedMetadata.builder().withIdentifier(arg));
+ builders.push(new BuilderAndArg(ImmutableNormalizedMetadata.builder(), arg));
}
// Step two: set the top builder's metadata
- builders.peek().withAnnotation(NETCONF_OPERATION_QNAME_LEGACY, oper.toString().toLowerCase(Locale.US));
+ builders.peek().builder.withAnnotation(NETCONF_OPERATION_QNAME_LEGACY, oper.toString().toLowerCase(Locale.US));
// Step three: build the tree
while (true) {
- final ImmutableNormalizedMetadata currentMeta = builders.pop().build();
- final Builder parent = builders.peek();
+ final var current = builders.pop();
+ final var currentMeta = current.builder.build();
+ final var parent = builders.peek();
if (parent != null) {
- parent.withChild(currentMeta);
+ parent.builder.withChild(current.arg, currentMeta);
} else {
return currentMeta;
}
rpcNS.setAttribute(XmlNetconfConstants.MESSAGE_ID, counter.getNewMessageId(MESSAGE_ID_PREFIX));
final Element actionNS = document.createElementNS(YangConstants.RFC6020_YANG_NAMESPACE_STRING, "action");
- final DataSchemaContextNode<?> rootSchemaContextNode = dataSchemaContextTree.getRoot();
+ final DataSchemaContext rootSchemaContextNode = dataSchemaContextTree.getRoot();
final Element actionData = prepareActionData(rootSchemaContextNode, actionNS,
domDataTreeIdentifier.getRootIdentifier().getPathArguments().iterator(), document);
return new DOMResult(specificActionElement);
}
- private static Element prepareActionData(final DataSchemaContextNode<?> currentParentSchemaNode,
+ private static Element prepareActionData(final DataSchemaContext currentParentSchemaNode,
final Element actionNS, final Iterator<PathArgument> iterator, final Document document) {
if (iterator.hasNext()) {
final PathArgument next = iterator.next();
- final DataSchemaContextNode<?> current = currentParentSchemaNode.getChild(next);
+ final DataSchemaContext current = currentParentSchemaNode instanceof DataSchemaContext.Composite composite
+ ? composite.childByArg(next) : null;
Preconditions.checkArgument(current != null, "Invalid input: schema for argument %s not found", next);
- if (current.isMixin()) {
+ if (current instanceof PathMixin) {
return prepareActionData(current, actionNS, iterator, document);
}
import org.opendaylight.netconf.client.mdsal.api.ActionTransformer;
import org.opendaylight.netconf.client.mdsal.api.NotificationTransformer;
import org.opendaylight.netconf.client.mdsal.api.RpcTransformer;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
@VisibleForTesting
static ImmutableMap<Absolute, ActionDefinition> getActions(final EffectiveModelContext schemaContext) {
final var builder = ImmutableMap.<Absolute, ActionDefinition>builder();
- findAction(schemaContext, new ArrayDeque<QName>(), builder);
+ findAction(schemaContext, new ArrayDeque<>(), builder);
return builder.build();
}
@GuardedBy("this")
private ContainerNode toNotification(final Absolute notificationPath, final Element element) {
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
try {
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final XmlParserStream xmlParser = XmlParserStream.create(writer, mountContext,
| UnsupportedOperationException e) {
throw new IllegalArgumentException(String.format("Failed to parse notification %s", element), e);
}
- return (ContainerNode) resultHolder.getResult();
+ return (ContainerNode) resultHolder.getResult().data();
}
private Optional<NestedNotificationInfo> findNestedNotification(final NetconfMessage message,
final var inference = SchemaInferenceStack.of(mountContext.getEffectiveModelContext(), outputPath)
.toInference();
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final Element element = message.getDocument().getDocumentElement();
try {
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
} catch (XMLStreamException | URISyntaxException | IOException | SAXException e) {
throw new IllegalArgumentException(String.format("Failed to parse RPC response %s", element), e);
}
- return (ContainerNode) resultHolder.getResult();
+ return (ContainerNode) resultHolder.getResult().data();
}
@Beta
import javax.xml.stream.XMLStreamException;
import org.opendaylight.netconf.api.EffectiveOperation;
import org.opendaylight.netconf.common.mdsal.NormalizedDataUtil;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode;
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.MountPointContext;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;
public Optional<NormalizedNode> selectFromDataStructure(final DataContainerChild data,
final YangInstanceIdentifier path) {
if (data instanceof DOMSourceAnyxmlNode) {
- final NormalizedNodeResult node;
+ final NormalizationResultHolder node;
try {
node = NormalizedDataUtil.transformDOMSourceToNormalizedNode(mountContext,
((DOMSourceAnyxmlNode)data).body());
- return NormalizedNodes.findNode(node.getResult(), path.getPathArguments());
+ return NormalizedNodes.findNode(node.getResult().data(), path.getPathArguments());
} catch (final XMLStreamException | URISyntaxException | IOException | SAXException e) {
LOG.error("Cannot parse anyxml.", e);
return Optional.empty();
import org.opendaylight.netconf.client.mdsal.impl.NetconfBaseOps;
import org.opendaylight.netconf.client.mdsal.impl.NetconfRpcFutureCallback;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.common.ErrorSeverity;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.netconf.dom.api.tx.NetconfDOMFieldsReadTransaction;
import org.opendaylight.netconf.dom.api.tx.NetconfDOMFieldsReadWriteTransaction;
import org.opendaylight.netconf.dom.api.tx.NetconfDOMFieldsTransactionChain;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
public final class NetconfDeviceDataBroker implements PingPongMergingDOMDataBroker {
private final NetconfDOMDataBrokerFieldsExtension fieldsExtension = new NetconfDOMDataBrokerFieldsExtensionImpl();
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.URL;
-import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.junit.Before;
@Test
public void testGetSource() throws Exception {
var source = yangLibrarySchemaYangSourceProvider.getSource(workingSid);
- final String x = source.get().asCharSource(StandardCharsets.UTF_8).read();
+ final String x = source.get().read();
assertThat(x, containsString("module config-test-rpc"));
}
import org.opendaylight.netconf.api.messages.NotificationMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformer;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
getNotificationSchemaContext(Collections.singleton("/schemas/nested-notification.yang"));
final NetconfMessage notificationMessage = prepareNotification("/nested-notification-payload.xml");
NetconfMessageTransformer messageTransformer = new NetconfMessageTransformer(
- new EmptyMountPointContext(schemaContext), true, BASE_SCHEMAS.getBaseSchema());
+ MountPointContext.of(schemaContext), true, BASE_SCHEMAS.getBaseSchema());
final DOMNotification domNotification = messageTransformer.toNotification(notificationMessage);
final ContainerNode root = domNotification.getBody();
assertNotNull(root);
assertEquals(1, root.body().size());
- assertEquals("interface-enabled", root.getIdentifier().getNodeType().getLocalName());
+ assertEquals("interface-enabled", root.name().getNodeType().getLocalName());
assertEquals(NotificationMessage.RFC3339_DATE_PARSER.apply("2008-07-08T00:01:00Z"),
((DOMEvent) domNotification).getEventInstant());
assertEquals(Absolute.of(INTERFACES_QNAME, INTERFACE_QNAME, INTERFACE_ENABLED_NOTIFICATION_QNAME),
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.slf4j.Logger;
public void setUp() throws Exception {
schemaContext = BASE_SCHEMAS.getBaseSchemaWithNotifications().getEffectiveModelContext();
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final XmlParserStream xmlParser = XmlParserStream.create(writer,
SchemaInferenceStack.ofDataTreePath(schemaContext, NetconfState.QNAME, Schemas.QNAME).toInference(), false);
xmlParser.parse(UntrustedXML.createXMLStreamReader(getClass().getResourceAsStream(
"/netconf-state.schemas.payload.xml")));
- compositeNodeSchemas = (ContainerNode) resultHolder.getResult();
+ compositeNodeSchemas = (ContainerNode) resultHolder.getResult().data();
}
@Test
import org.opendaylight.netconf.api.messages.NotificationMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformer;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@Test
public void testMostRecentWrongYangModel() throws Exception {
final EffectiveModelContext schemaContext = getNotificationSchemaContext(getClass(), true);
- messageTransformer = new NetconfMessageTransformer(new EmptyMountPointContext(schemaContext), true,
+ messageTransformer = new NetconfMessageTransformer(MountPointContext.of(schemaContext), true,
BASE_SCHEMAS.getBaseSchema());
assertThrows(IllegalArgumentException.class, () -> messageTransformer.toNotification(userNotification));
}
@Test
public void testToNotificationFunction() throws Exception {
final EffectiveModelContext schemaContext = getNotificationSchemaContext(getClass(), false);
- messageTransformer = new NetconfMessageTransformer(new EmptyMountPointContext(schemaContext), true,
+ messageTransformer = new NetconfMessageTransformer(MountPointContext.of(schemaContext), true,
BASE_SCHEMAS.getBaseSchema());
final DOMNotification domNotification = messageTransformer.toNotification(userNotification);
final ContainerNode root = domNotification.getBody();
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformer;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
@Before
public void before() {
- messageTransformer = new NetconfMessageTransformer(new EmptyMountPointContext(cfgCtx), true,
+ messageTransformer = new NetconfMessageTransformer(MountPointContext.of(cfgCtx), true,
BASE_SCHEMAS.getBaseSchema());
}
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.client.mdsal.spi.NetconfDeviceRpc;
import org.opendaylight.netconf.common.mdsal.NormalizedDataUtil;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
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.MountPointContext;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_COMMIT_QNAME)))
.thenReturn(RpcResultBuilder.success(ok).buildFuture());
final var rpc = new NetconfDeviceRpc(SCHEMA_CONTEXT, listener, new NetconfMessageTransformer(
- new EmptyMountPointContext(SCHEMA_CONTEXT), true, BASE_SCHEMAS.getBaseSchema()));
+ MountPointContext.of(SCHEMA_CONTEXT), true, BASE_SCHEMAS.getBaseSchema()));
callback = new NetconfRpcFutureCallback("prefix",
new RemoteDeviceId("device-1", InetSocketAddress.createUnresolved("localhost", 17830)));
- baseOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
+ baseOps = new NetconfBaseOps(rpc, MountPointContext.of(SCHEMA_CONTEXT));
}
@Test
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.Session;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfConfigChange;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.netconf.config.change.Edit;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
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.NormalizedNodeResult;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
XMLUnit.setIgnoreComments(true);
netconfMessageTransformer = getTransformer(SCHEMA);
- actionNetconfMessageTransformer = new NetconfMessageTransformer(new EmptyMountPointContext(ACTION_SCHEMA),
+ actionNetconfMessageTransformer = new NetconfMessageTransformer(MountPointContext.of(ACTION_SCHEMA),
true, BASE_SCHEMAS.getBaseSchema());
}
@Test
public void testCreateSubscriberNotificationSchemaNotPresent() throws Exception {
- final NetconfMessageTransformer transformer = new NetconfMessageTransformer(new EmptyMountPointContext(SCHEMA),
- true, BASE_SCHEMAS.getBaseSchemaWithNotifications());
+ final NetconfMessageTransformer transformer = new NetconfMessageTransformer(MountPointContext.of(SCHEMA), true,
+ BASE_SCHEMAS.getBaseSchemaWithNotifications());
NetconfMessage netconfMessage = transformer.toRpcRequest(CREATE_SUBSCRIPTION_RPC_QNAME,
CREATE_SUBSCRIPTION_RPC_CONTENT);
String documentString = XmlUtil.toString(netconfMessage.getDocument());
final DOMSourceAnyxmlNode data = (DOMSourceAnyxmlNode) compositeNodeRpcResult.value()
.findChildByArg(toId(NETCONF_DATA_QNAME)).orElseThrow();
- NormalizedNodeResult nodeResult = NormalizedDataUtil.transformDOMSourceToNormalizedNode(SCHEMA, data.body());
- ContainerNode result = (ContainerNode) nodeResult.getResult();
+ var nodeResult = NormalizedDataUtil.transformDOMSourceToNormalizedNode(SCHEMA, data.body());
+ ContainerNode result = (ContainerNode) nodeResult.getResult().data();
final ContainerNode state = (ContainerNode) result.getChildByArg(toId(NetconfState.QNAME));
final ContainerNode schemas = (ContainerNode) state.getChildByArg(toId(Schemas.QNAME));
final MapNode schemaParent = (MapNode) schemas.getChildByArg(toId(Schema.QNAME));
}
private static NetconfMessageTransformer getTransformer(final EffectiveModelContext schema) {
- return new NetconfMessageTransformer(new EmptyMountPointContext(schema), true, BASE_SCHEMAS.getBaseSchema());
+ return new NetconfMessageTransformer(MountPointContext.of(schema), true, BASE_SCHEMAS.getBaseSchema());
}
@Test
List<PathArgument> nodeIdentifiers = new ArrayList<>();
nodeIdentifiers.add(NodeIdentifier.create(SERVER_QNAME));
nodeIdentifiers.add(NodeIdentifierWithPredicates.of(SERVER_QNAME, serverNameQname, "testServer"));
- nodeIdentifiers.add(new AugmentationIdentifier(Set.of(APPLICATIONS_QNAME)));
nodeIdentifiers.add(NodeIdentifier.create(APPLICATIONS_QNAME));
nodeIdentifiers.add(NodeIdentifier.create(APPLICATION_QNAME));
nodeIdentifiers.add(NodeIdentifierWithPredicates.of(APPLICATION_QNAME,
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceId;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Rpcs;
import org.opendaylight.netconf.client.mdsal.impl.NetconfBaseOps;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
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.MountPointContext;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class FieldsAwareReadOnlyTxTest {
try (var readOnlyTx = new FieldsAwareReadOnlyTx(netconfOps,
new RemoteDeviceId("a", new InetSocketAddress("localhost", 196)))) {
- readOnlyTx.read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty(),
- List.of(YangInstanceIdentifier.empty()));
+ readOnlyTx.read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.of(),
+ List.of(YangInstanceIdentifier.of()));
verify(rpc).invokeNetconf(eq(NETCONF_GET_CONFIG_QNAME), any());
- readOnlyTx.read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
+ readOnlyTx.read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.of());
verify(rpc).invokeNetconf(eq(NETCONF_GET_QNAME), any());
}
}
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class NetconfDataTreeServiceImplTest extends AbstractTestModelTest {
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(rpcService).invokeNetconf(any(), any());
netconService = getNetconService();
final var model = BindingRuntimeHelpers.createEffectiveModel(IetfNetconfService.class, NetconfState.class);
- netconfMessageTransformer = new NetconfMessageTransformer(new EmptyMountPointContext(model), true,
+ netconfMessageTransformer = new NetconfMessageTransformer(MountPointContext.of(model), true,
BASE_SCHEMAS.getBaseSchema());
}
NetconfSessionPreferences prefs = NetconfSessionPreferences.fromStrings(List.of(CapabilityURN.CANDIDATE));
final RemoteDeviceId id =
new RemoteDeviceId("device-1", InetSocketAddress.createUnresolved("localhost", 17830));
- return AbstractNetconfDataTreeService.of(id, new EmptyMountPointContext(SCHEMA_CONTEXT), rpcService, prefs,
+ return AbstractNetconfDataTreeService.of(id, MountPointContext.of(SCHEMA_CONTEXT), rpcService, prefs,
true);
}
}
import org.opendaylight.netconf.dom.api.tx.NetconfDOMFieldsReadWriteTransaction;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netconf.monitoring.rev220718.NetconfTcp;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
@RunWith(MockitoJUnitRunner.class)
NetconfSessionPreferences prefs = NetconfSessionPreferences.fromStrings(List.of(caps));
final RemoteDeviceId id =
new RemoteDeviceId("device-1", InetSocketAddress.createUnresolved("localhost", 17830));
- return new NetconfDeviceDataBroker(id, new EmptyMountPointContext(SCHEMA_CONTEXT), rpcService, prefs, true);
+ return new NetconfDeviceDataBroker(id, MountPointContext.of(SCHEMA_CONTEXT), rpcService, prefs, true);
}
}
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformUtil;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.IetfNetconfService;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
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.MountPointContext;
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;
@Before
public void setUp() throws Exception {
NetconfMessageTransformer transformer = new NetconfMessageTransformer(
- new EmptyMountPointContext(SCHEMA_CONTEXT), true, BASE_SCHEMAS.getBaseSchema());
+ MountPointContext.of(SCHEMA_CONTEXT), true, BASE_SCHEMAS.getBaseSchema());
final NetconfMessage reply = new NetconfMessage(XmlUtil.readXmlToDocument(
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
+ "<rpc-reply xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" message-id=\"101\">\n"
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices;
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Rpcs;
import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
final var netconfSessionPreferences = NetconfSessionPreferences.fromStrings(List.of(CapabilityURN.CANDIDATE));
final var deviceServices = new RemoteDeviceServices(mock(Rpcs.Normalized.class), null);
deviceFacade.onDeviceConnected(
- new NetconfDeviceSchema(NetconfDeviceCapabilities.empty(), new EmptyMountPointContext(schemaContext)),
+ new NetconfDeviceSchema(NetconfDeviceCapabilities.empty(), MountPointContext.of(schemaContext)),
netconfSessionPreferences, deviceServices);
verify(mountInstance, times(1)).onDeviceConnected(eq(schemaContext), eq(deviceServices),
import org.opendaylight.netconf.client.mdsal.impl.NetconfBaseOps;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
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.MapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Rpcs;
import org.opendaylight.netconf.client.mdsal.impl.NetconfBaseOps;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformUtil;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
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.MountPointContext;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class ReadOnlyTxTest {
import org.opendaylight.netconf.client.mdsal.impl.NetconfBaseOps;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.copy.config.input.target.ConfigTarget;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
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.MountPointContext;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
@Before
public void setUp() {
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(rpc).invokeNetconf(any(), any());
- netconfOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
+ netconfOps = new NetconfBaseOps(rpc, MountPointContext.of(SCHEMA_CONTEXT));
id = new RemoteDeviceId("device1", InetSocketAddress.createUnresolved("0.0.0.0", 17830));
}
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Rpcs;
import org.opendaylight.netconf.client.mdsal.impl.NetconfBaseOps;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformUtil;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class WriteCandidateTxTest extends AbstractTestModelTest {
@Before
public void setUp() {
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(rpc).invokeNetconf(any(), any());
- netconfOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
+ netconfOps = new NetconfBaseOps(rpc, MountPointContext.of(SCHEMA_CONTEXT));
}
@Test
import org.opendaylight.netconf.client.mdsal.api.RemoteDeviceServices.Rpcs;
import org.opendaylight.netconf.client.mdsal.impl.NetconfBaseOps;
import org.opendaylight.netconf.client.mdsal.impl.NetconfMessageTransformUtil;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class WriteRunningTxTest extends AbstractTestModelTest {
@Before
public void setUp() {
doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(rpc).invokeNetconf(any(), any());
- netconfOps = new NetconfBaseOps(rpc, new EmptyMountPointContext(SCHEMA_CONTEXT));
+ netconfOps = new NetconfBaseOps(rpc, MountPointContext.of(SCHEMA_CONTEXT));
}
@Test
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-util</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc7952-data-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc7952-data-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc8528-data-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc8528-data-util</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
import java.util.Map;
import javax.xml.stream.XMLStreamWriter;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.rfc7952.data.api.NormalizedMetadata;
-import org.opendaylight.yangtools.rfc7952.data.api.StreamWriterMetadataExtension;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedMetadata;
import org.opendaylight.yangtools.yang.data.api.schema.stream.ForwardingNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
final class EmptyListXmlMetadataWriter extends ForwardingNormalizedNodeStreamWriter {
private final Deque<NormalizedMetadata> stack = new ArrayDeque<>();
private final EmptyListXmlWriter dataWriterDelegate;
- private final StreamWriterMetadataExtension metaWriter;
+ private final MetadataExtension metaWriter;
private final NormalizedMetadata metadata;
private int absentDepth = 0;
EmptyListXmlMetadataWriter(final @NonNull NormalizedNodeStreamWriter writer,
- final @NonNull XMLStreamWriter xmlStreamWriter, final @NonNull StreamWriterMetadataExtension metaWriter,
+ final @NonNull XMLStreamWriter xmlStreamWriter, final @NonNull MetadataExtension metaWriter,
final @NonNull NormalizedMetadata metadata) {
dataWriterDelegate = new EmptyListXmlWriter(requireNonNull(writer), requireNonNull(xmlStreamWriter));
this.metaWriter = requireNonNull(metaWriter);
enterMetadataNode(name);
}
- @Override
- public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
- dataWriterDelegate.startAugmentationNode(identifier);
- enterMetadataNode(identifier);
- }
-
@Override
public boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
final boolean ret = dataWriterDelegate.startAnyxmlNode(name, objectModel);
import javax.xml.transform.dom.DOMSource;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netconf.api.xml.XmlUtil;
-import org.opendaylight.yangtools.rfc7952.data.api.NormalizedMetadata;
-import org.opendaylight.yangtools.rfc7952.data.api.StreamWriterMetadataExtension;
-import org.opendaylight.yangtools.rfc7952.data.util.NormalizedMetadataWriter;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedMetadata;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedMetadataWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.MetadataExtension;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XMLStreamNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
XML_NAMESPACE_SETTER.initializeNamespace(xmlWriter);
try (var streamWriter = XMLStreamNormalizedNodeStreamWriter.create(xmlWriter, context, path);
var writer = new EmptyListXmlMetadataWriter(streamWriter, xmlWriter,
- streamWriter.getExtensions().getInstance(StreamWriterMetadataExtension.class), metadata)) {
+ streamWriter.extension(MetadataExtension.class), metadata)) {
final Iterator<PathArgument> it = query.getPathArguments().iterator();
final PathArgument first = it.next();
StreamingContext.fromSchemaAndQNameChecked(context, first.getNodeType()).streamToWriter(writer, first, it);
return rootTreeNode;
}
- public static NormalizedNodeResult transformDOMSourceToNormalizedNode(final MountPointContext mount,
+ public static NormalizationResultHolder transformDOMSourceToNormalizedNode(final MountPointContext mount,
final DOMSource value) throws XMLStreamException, URISyntaxException, IOException, SAXException {
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
try (XmlParserStream xmlParserStream = XmlParserStream.create(writer, new ProxyMountPointContext(mount))) {
xmlParserStream.traverse(value);
}
// FIXME: document this interface contract. Does it support RFC8528/RFC8542? How?
- public static NormalizedNodeResult transformDOMSourceToNormalizedNode(final EffectiveModelContext schemaContext,
- final DOMSource value) throws XMLStreamException, URISyntaxException, IOException, SAXException {
- return transformDOMSourceToNormalizedNode(new EmptyMountPointContext(schemaContext), value);
+ public static NormalizationResultHolder transformDOMSourceToNormalizedNode(
+ final EffectiveModelContext schemaContext, final DOMSource value)
+ throws XMLStreamException, URISyntaxException, IOException, SAXException {
+ return transformDOMSourceToNormalizedNode(MountPointContext.of(schemaContext), value);
}
}
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Delegator;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContextFactory;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointIdentifier;
+import org.opendaylight.yangtools.yang.common.MountPointLabel;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContextFactory;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
}
@Override
- public Optional<MountPointContextFactory> findMountPoint(final MountPointIdentifier label) {
+ public Optional<MountPointContextFactory> findMountPoint(final MountPointLabel label) {
return delegate.findMountPoint(label);
}
}
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
abstract class StreamingContext<T extends PathArgument> implements Identifiable<T> {
private final T identifier;
checkArgument(potential.isPresent(),
"Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,
schema.getChildNodes());
-
- final DataSchemaNode result = potential.orElseThrow();
- // We try to look up if this node was added by augmentation
- if (schema instanceof DataSchemaNode && result.isAugmenting()) {
- for (final AugmentationSchemaNode aug : ((AugmentationTarget)schema).getAvailableAugmentations()) {
- if (aug.dataChildByName(result.getQName()) != null) {
- return new Augmentation(aug, schema);
- }
- }
- }
- return fromDataSchemaNode(result);
+ return fromDataSchemaNode(potential.orElseThrow());
}
static StreamingContext<?> fromDataSchemaNode(final DataSchemaNode potential) {
}
private StreamingContext<?> fromLocalSchema(final PathArgument child) {
- if (child instanceof AugmentationIdentifier aid) {
- return fromSchemaAndQNameChecked(schema, aid.getPossibleChildNames().iterator().next());
- }
return fromSchemaAndQNameChecked(schema, child.getNodeType());
}
}
}
}
- private static final class Augmentation extends AbstractDataContainer<AugmentationIdentifier> {
- Augmentation(final AugmentationSchemaNode augmentation, final DataNodeContainer schema) {
- super(DataSchemaContextNode.augmentationIdentifierFrom(augmentation),
- new EffectiveAugmentationSchema(augmentation, schema));
- }
-
- @Override
- boolean isMixin() {
- return true;
- }
-
- @Override
- void emitElementStart(final NormalizedNodeStreamWriter writer, final PathArgument arg,
- final int childSizeHint) throws IOException {
- writer.startAugmentationNode(getIdentifier());
- }
- }
-
private static final class UnorderedMapMixin extends AbstractMapMixin {
UnorderedMapMixin(final ListSchemaNode list) {
super(list);
<packaging>bundle</packaging>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-common</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc7952-data-api</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-api</artifactId>
import static java.util.Objects.requireNonNull;
-import com.google.common.io.CharStreams;
import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
final String revision = module.getRevision().map(Revision::toString).orElse(null);
final SourceIdentifier moduleSourceIdentifier = new SourceIdentifier(moduleName, revision);
- InputStream sourceStream = null;
String source;
try {
- sourceStream = rootSchemaSourceProviderDependency.getSource(moduleSourceIdentifier).get().openStream();
- source = CharStreams.toString(new InputStreamReader(sourceStream, StandardCharsets.UTF_8));
+ source = rootSchemaSourceProviderDependency.getSource(moduleSourceIdentifier).get().read();
} catch (ExecutionException | InterruptedException | IOException e) {
LOG.warn("Ignoring source for module {}. Unable to read content", moduleSourceIdentifier, e);
source = null;
}
- try {
- if (sourceStream != null) {
- sourceStream.close();
- }
- } catch (IOException e) {
- LOG.warn("Error closing yang source stream {}. Ignoring", moduleSourceIdentifier, e);
- }
-
if (source != null) {
return Optional.of(new YangModuleCapability(moduleNamespace, moduleName, revision, source));
}
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableMetadataNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeMetadataResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
/**
* This is a single component writer, which results in some amount.
super(state);
}
- ComponentNormalizedNodeStreamWriter(final NormalizedNodeMetadataResult result) {
+ ComponentNormalizedNodeStreamWriter(final NormalizationResultHolder result) {
super(result);
}
import org.opendaylight.yangtools.yang.data.codec.xml.XMLStreamNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
// Then create nodes present in the <config> element:
for (final XmlElement element : configElements) {
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
parseIntoNormalizedNode(getSchemaNodeFromNamespace(element.getNamespace(), element), element,
ImmutableNormalizedNodeStreamWriter.from(resultHolder));
- final NormalizedNode data = resultHolder.getResult();
+ final NormalizedNode data = resultHolder.getResult().data();
final YangInstanceIdentifier path = YangInstanceIdentifier.create(data.getIdentifier());
// Doing merge instead of put to support top-level list:
rwTx.merge(LogicalDatastoreType.CONFIGURATION, path, data);
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
final var dataSchemaNode = DataSchemaContextTree.from(schemaContext.getCurrentContext())
.findChild(parentNodeYid)
.orElseThrow(() -> new IllegalStateException("Cannot find schema for " + parentNodeYid))
- .getDataSchemaNode();
+ .dataSchemaNode();
// we should have the schema node that points to the parent list now, enforce it
if (!(dataSchemaNode instanceof ListSchemaNode listSchemaNode)) {
(listSchemaNode.isUserOrdered() ? Builders.orderedMapBuilder() : Builders.mapBuilder())
.withNodeIdentifier(new NodeIdentifier(parentNodeYid.getLastPathArgument().getNodeType()))
.build());
- } else if (parentNodeYid.getLastPathArgument() instanceof AugmentationIdentifier augId) {
- // merge empty augmentation node
- rwtx.merge(LogicalDatastoreType.CONFIGURATION, parentNodeYid, Builders.augmentationBuilder()
- .withNodeIdentifier(augId)
- .build());
}
}
import org.opendaylight.yangtools.yang.data.codec.xml.XMLStreamNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaOrderedNormalizedNodeWriter;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
*/
private @Nullable ContainerNode rpcToNNode(final XmlElement element,
final RpcDefinition rpcDefinition) throws DocumentedException {
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final XmlParserStream xmlParser = XmlParserStream.create(writer, SchemaInferenceStack.of(
schemaContext.getCurrentContext(),
ErrorType.PROTOCOL, ErrorTag.MALFORMED_MESSAGE, ErrorSeverity.ERROR);
}
- return (ContainerNode) resultHolder.getResult();
+ return (ContainerNode) resultHolder.getResult().data();
}
}
import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
-import com.google.common.collect.ClassToInstanceMap;
-import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Deque;
import java.util.List;
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.netconf.api.EffectiveOperation;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.EditConfigInput;
-import org.opendaylight.yangtools.rfc7952.data.api.StreamWriterMetadataExtension;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriterExtension;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.MetadataExtension;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeMetadataResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-final class SplittingNormalizedNodeMetadataStreamWriter implements NormalizedNodeStreamWriter,
- StreamWriterMetadataExtension {
+final class SplittingNormalizedNodeMetadataStreamWriter implements NormalizedNodeStreamWriter, MetadataExtension {
private static final Logger LOG = LoggerFactory.getLogger(SplittingNormalizedNodeMetadataStreamWriter.class);
private static final QName OPERATION_ATTRIBUTE = QName.create(EditConfigInput.QNAME.getNamespace(),
XmlNetconfConstants.OPERATION_ATTR_KEY);
// Top-level result node
- private final NormalizedNodeMetadataResult result = new NormalizedNodeMetadataResult();
+ private final NormalizationResultHolder result = new NormalizationResultHolder();
// Split-out changes
private final List<DataTreeChange> dataTreeChanges = new ArrayList<>();
// Path of the node we are currently in
}
@Override
- public ClassToInstanceMap<NormalizedNodeStreamWriterExtension> getExtensions() {
- return ImmutableClassToInstanceMap.of(StreamWriterMetadataExtension.class, this);
+ public Collection<? extends Extension> supportedExtensions() {
+ return List.of(this);
}
@Override
pushPath(name);
}
- @Override
- public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
- writer.startAugmentationNode(identifier);
- pushPath(identifier);
- }
-
-
@Override
public boolean startAnydataNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
// FIXME: add anydata support
// All done, special-cased
LOG.debug("All done ... writer {}", writer);
writer.endNode();
- dataTreeChanges.add(new DataTreeChange(result.getResult(), currentAction, currentPath));
+ dataTreeChanges.add(new DataTreeChange(result.getResult().data(), currentAction, currentPath));
}
}
import static org.junit.Assert.fail;
import static org.opendaylight.yangtools.yang.test.util.YangParserTestUtils.parseYangResources;
-import com.google.common.io.ByteSource;
+import com.google.common.io.CharSource;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import java.io.IOException;
final DOMStore operStore = InMemoryDOMDataStoreFactory.create("DOM-OPER", schemaService);
final DOMStore configStore = InMemoryDOMDataStoreFactory.create("DOM-CFG", schemaService);
- currentSchemaContext = CurrentSchemaContext.create(schemaService, sourceIdentifier -> {
- final YangTextSchemaSource yangTextSchemaSource =
- YangTextSchemaSource.delegateForByteSource(sourceIdentifier, ByteSource.wrap("module test".getBytes()));
- return Futures.immediateFuture(yangTextSchemaSource);
- });
+ currentSchemaContext = CurrentSchemaContext.create(schemaService,
+ sourceIdentifier -> Futures.immediateFuture(YangTextSchemaSource.delegateForCharSource(sourceIdentifier,
+ CharSource.wrap("module test"))));
- final EnumMap<LogicalDatastoreType, DOMStore> datastores = new EnumMap<>(LogicalDatastoreType.class);
+ final var datastores = new EnumMap<LogicalDatastoreType, DOMStore>(LogicalDatastoreType.class);
datastores.put(LogicalDatastoreType.CONFIGURATION, configStore);
datastores.put(LogicalDatastoreType.OPERATIONAL, operStore);
import static org.mockito.Mockito.doNothing;
import com.google.common.base.Preconditions;
-import com.google.common.io.ByteSource;
+import com.google.common.io.CharSource;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.io.IOException;
XMLUnit.setIgnoreWhitespace(true);
XMLUnit.setIgnoreAttributeOrder(true);
- doAnswer(invocationOnMock -> {
- final SourceIdentifier sId = (SourceIdentifier) invocationOnMock.getArguments()[0];
- final YangTextSchemaSource yangTextSchemaSource =
- YangTextSchemaSource.delegateForByteSource(sId, ByteSource.wrap("module test".getBytes()));
- return Futures.immediateFuture(yangTextSchemaSource);
- }).when(sourceProvider).getSource(any(SourceIdentifier.class));
+ doAnswer(invocationOnMock -> Futures.immediateFuture(YangTextSchemaSource.delegateForCharSource(
+ (SourceIdentifier) invocationOnMock.getArguments()[0], CharSource.wrap("module test"))))
+ .when(sourceProvider).getSource(any(SourceIdentifier.class));
currentSchemaContext = CurrentSchemaContext.create(schemaService, sourceProvider);
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<packaging>bundle</packaging>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<packaging>bundle</packaging>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<name>${project.artifactId}</name>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>netconf-api</artifactId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
@Override
public YangInstanceIdentifier getInstanceIdentifier() {
- return YangInstanceIdentifier.empty();
+ return YangInstanceIdentifier.of();
}
@Override
@Override
InstanceIdentifierContext createWithConcapt(final List<PathArgument> concatArgs) {
return new DataPath(context, getMountPoint(), SchemaInferenceStack.of(context),
- YangInstanceIdentifier.create(concatArgs));
+ YangInstanceIdentifier.of(concatArgs));
}
}
static @NonNull DataPath of(final EffectiveModelContext context, final YangInstanceIdentifier path,
final DOMMountPoint mountPoint) {
final var nodeAndStack = DataSchemaContextTree.from(context).enterPath(path).orElseThrow();
- return new DataPath(nodeAndStack.node().getDataSchemaNode(), mountPoint, nodeAndStack.stack(), path);
+ return new DataPath(nodeAndStack.node().dataSchemaNode(), mountPoint, nodeAndStack.stack(), path);
}
@Override
@Override
@NonNull
InstanceIdentifierContext createWithConcapt(final List<PathArgument> concatArgs) {
- final var newInstanceIdentifier = YangInstanceIdentifier.create(
+ final var newInstanceIdentifier = YangInstanceIdentifier.of(
Iterables.concat(path.getPathArguments(), concatArgs));
return new DataPath(getSchemaNode(), getMountPoint(), stack, newInstanceIdentifier);
}
<packaging>bundle</packaging>
<dependencies>
+ <dependency>
+ <groupId>com.github.spotbugs</groupId>
+ <artifactId>spotbugs-annotations</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc8528-data-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>rfc8528-data-util</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-api</artifactId>
import static java.util.Objects.requireNonNull;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
-import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
+import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlCodecFactory;
}
public static @NonNull DatabindContext ofModel(final EffectiveModelContext modelContext) {
- return ofMountPoint(new EmptyMountPointContext(modelContext));
+ return ofMountPoint(MountPointContext.of(modelContext));
}
public static @NonNull DatabindContext ofMountPoint(final MountPointContext mountContext) {
import org.opendaylight.yangtools.yang.common.ErrorType;
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.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.data.impl.schema.ResultAlreadySetException;
import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
public static NormalizedNodePayload readFrom(
final InstanceIdentifierContext path, final InputStream entityStream, final boolean isPost) {
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final Inference parentSchema;
final JsonReader reader = new JsonReader(new InputStreamReader(entityStream, StandardCharsets.UTF_8));
jsonParser.parse(reader);
- NormalizedNode result = resultHolder.getResult();
+ NormalizedNode result = resultHolder.getResult().data();
final List<YangInstanceIdentifier.PathArgument> iiToDataList = new ArrayList<>();
- while (result instanceof AugmentationNode || result instanceof ChoiceNode) {
- final var childNode = ((DataContainerNode) result).body().iterator().next();
+ while (result instanceof ChoiceNode choice) {
+ final var childNode = choice.body().iterator().next();
if (isPost) {
iiToDataList.add(result.getIdentifier());
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
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.DataContainerChild;
return true;
}
- // always write augmentation nodes
- if (node instanceof AugmentationNode) {
- return true;
- }
-
// write only selected nodes
if (currentDepth > 0 && currentDepth <= fields.size()) {
- return fields.get(currentDepth - 1).contains(node.getIdentifier().getNodeType());
+ return fields.get(currentDepth - 1).contains(node.name().getNodeType());
}
// after this depth only depth parameter is used to determine when to write node
private boolean wasProcessedAsCompositeNode(final NormalizedNode node) throws IOException {
boolean processedAsCompositeNode = false;
if (node instanceof ContainerNode n) {
- if (!n.getIdentifier().getNodeType().withoutRevision().equals(ROOT_DATA_QNAME)) {
- writer.startContainerNode(n.getIdentifier(), n.size());
+ if (!n.name().getNodeType().withoutRevision().equals(ROOT_DATA_QNAME)) {
+ writer.startContainerNode(n.name(), n.size());
currentDepth++;
processedAsCompositeNode = writeChildren(n.body(), false);
currentDepth--;
} else if (node instanceof MapEntryNode n) {
processedAsCompositeNode = writeMapEntryNode(n);
} else if (node instanceof UnkeyedListEntryNode n) {
- writer.startUnkeyedListItem(n.getIdentifier(), n.size());
+ writer.startUnkeyedListItem(n.name(), n.size());
currentDepth++;
processedAsCompositeNode = writeChildren(n.body(), false);
currentDepth--;
} else if (node instanceof ChoiceNode n) {
- writer.startChoiceNode(n.getIdentifier(), n.size());
- processedAsCompositeNode = writeChildren(n.body(), true);
- } else if (node instanceof AugmentationNode n) {
- writer.startAugmentationNode(n.getIdentifier());
+ writer.startChoiceNode(n.name(), n.size());
processedAsCompositeNode = writeChildren(n.body(), true);
} else if (node instanceof UnkeyedListNode n) {
- writer.startUnkeyedList(n.getIdentifier(), n.size());
+ writer.startUnkeyedList(n.name(), n.size());
processedAsCompositeNode = writeChildren(n.body(), false);
} else if (node instanceof UserMapNode n) {
- writer.startOrderedMapNode(n.getIdentifier(), n.size());
+ writer.startOrderedMapNode(n.name(), n.size());
processedAsCompositeNode = writeChildren(n.body(), true);
} else if (node instanceof SystemMapNode n) {
- writer.startMapNode(n.getIdentifier(), n.size());
+ writer.startMapNode(n.name(), n.size());
processedAsCompositeNode = writeChildren(n.body(), true);
} else if (node instanceof LeafSetNode<?> n) {
if (n.ordering() == Ordering.USER) {
- writer.startOrderedLeafSet(n.getIdentifier(), n.size());
+ writer.startOrderedLeafSet(n.name(), n.size());
} else {
- writer.startLeafSet(n.getIdentifier(), n.size());
+ writer.startLeafSet(n.name(), n.size());
}
currentDepth++;
processedAsCompositeNode = writeChildren(n.body(), true);
@Override
protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
final NormalizedNodeStreamWriter writer = getWriter();
- writer.startMapEntryNode(node.getIdentifier(), node.size());
+ writer.startMapEntryNode(node.name(), node.size());
- final Set<QName> qnames = node.getIdentifier().keySet();
+ final Set<QName> qnames = node.name().keySet();
// Write out all the key children
currentDepth++;
for (final QName qname : qnames) {
// Write all the rest
final boolean result =
writeChildren(Iterables.filter(node.body(), input -> {
- if (input instanceof AugmentationNode) {
- return true;
- }
- if (!qnames.contains(input.getIdentifier().getNodeType())) {
+ if (!qnames.contains(input.name().getNodeType())) {
return true;
}
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext.PathMixin;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.ContainerLike;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final var stack = nodeAndStack.stack();
var current = nodeAndStack.node();
do {
- final var next = current.enterChild(stack, qname);
- checkState(next != null, "Child \"%s\" was not found in parent schema node \"%s\"", qname,
- schemaNode);
- iiToDataList.add(next.getIdentifier());
- schemaNode = next.getDataSchemaNode();
+ final var next = current instanceof DataSchemaContext.Composite compositeCurrent
+ ? compositeCurrent.enterChild(stack, qname) : null;
+ if (next == null) {
+ throw new IllegalStateException(
+ "Child \"" + qname + "\" was not found in parent schema node \"" + schemaNode + "\"");
+ }
+
+ // Careful about steps: for keyed list items the individual item does not have a PathArgument step,
+ // as we do not know the key values -- we supply that later
+ final var step = next.pathStep();
+ if (step != null) {
+ iiToDataList.add(step);
+ }
+ schemaNode = next.dataSchemaNode();
current = next;
- } while (current.isMixin());
-
- // We need to unwind the last identifier if it a NodeIdentifierWithPredicates, as it does not have
- // any predicates at all. The real identifier is then added below
- if (stack.currentStatement() instanceof ListEffectiveStatement) {
- iiToDataList.remove(iiToDataList.size() - 1);
- }
+ } while (current instanceof PathMixin);
inference = stack.toInference();
} else {
throw new IllegalStateException("Unknown SchemaNode " + schemaNodeContext);
}
-
NormalizedNode parsed;
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
if (schemaNode instanceof ContainerLike || schemaNode instanceof ListSchemaNode
|| schemaNode instanceof LeafSchemaNode) {
final XmlParserStream xmlParser = XmlParserStream.create(writer, inference);
xmlParser.traverse(new DOMSource(doc.getDocumentElement()));
- parsed = resultHolder.getResult();
+ parsed = resultHolder.getResult().data();
// When parsing an XML source with a list root node
// the new XML parser always returns a MapNode with one MapEntryNode inside.
}
if (schemaNode instanceof ListSchemaNode && isPost()) {
- iiToDataList.add(parsed.getIdentifier());
+ // Supply the last item
+ iiToDataList.add(parsed.name());
}
} else {
LOG.warn("Unknown schema node extension {} was not parsed", schemaNode.getClass());
import java.io.OutputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
import java.util.concurrent.ExecutionException;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
} catch (InterruptedException | ExecutionException e) {
throw new WebApplicationException("Unable to retrieve source from SourceProvider.", e);
}
- yangTextSchemaSource.copyTo(entityStream);
+ yangTextSchemaSource.asByteSource(StandardCharsets.UTF_8).copyTo(entityStream);
}
}
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.data.impl.schema.ResultAlreadySetException;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
*/
private static NormalizedNode readEditData(final @NonNull JsonReader in,
final @NonNull Inference targetSchemaNode, final @NonNull InstanceIdentifierContext path) {
- final var resultHolder = new NormalizedNodeResult();
+ final var resultHolder = new NormalizationResultHolder();
final var writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
JsonParserStream.create(writer, JSONCodecFactorySupplier.RFC7951.getShared(path.getSchemaContext()),
targetSchemaNode).parse(in);
- // In case AugmentationNode additional step to get actual data node is required
- var data = resultHolder.getResult();
- while (data instanceof AugmentationNode augNode) {
- final var it = augNode.body().iterator();
- verify(it.hasNext(), "Augmentation %s is missing child", data);
- data = it.next();
- }
- return data;
+ return resultHolder.getResult().data();
}
/**
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.slf4j.Logger;
}
if (oper.isWithValue()) {
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final XmlParserStream xmlParser = XmlParserStream.create(writer, inference);
xmlParser.traverse(new DOMSource(firstValueElement));
+ final var result = resultHolder.getResult().data();
// for lists allow to manipulate with list items through their parent
if (targetII.getLastPathArgument() instanceof NodeIdentifierWithPredicates) {
- resultCollection.add(new PatchEntity(editId, oper, targetII.getParent(), resultHolder.getResult()));
+ resultCollection.add(new PatchEntity(editId, oper, targetII.getParent(), result));
} else {
- resultCollection.add(new PatchEntity(editId, oper, targetII, resultHolder.getResult()));
+ resultCollection.add(new PatchEntity(editId, oper, targetII, result));
}
} else {
resultCollection.add(new PatchEntity(editId, oper, targetII));
import static java.util.Objects.requireNonNull;
-import com.google.common.collect.ImmutableSet;
import java.util.Set;
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
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.LeafNode;
private static final NodeIdentifier OUTPUT_TYPE_NODEID = NodeIdentifier.create(OUTPUT_TYPE_QNAME);
private static final NodeIdentifier DEVICE_NOTIFICATION_PATH_NODEID =
NodeIdentifier.create(DEVICE_NOTIFICATION_PATH_QNAME);
- private static final AugmentationIdentifier SAL_REMOTE_AUG_IDENTIFIER = new AugmentationIdentifier(
- ImmutableSet.of(SCOPE_QNAME, DATASTORE_QNAME, OUTPUT_TYPE_QNAME));
private CreateStreamUtil() {
// Hidden on purpose
}
private static @Nullable String extractStringLeaf(final ContainerNode data, final NodeIdentifier childName) {
- final DataContainerChild augNode = data.childByArg(SAL_REMOTE_AUG_IDENTIFIER);
- if (augNode instanceof AugmentationNode) {
- final DataContainerChild enumNode = ((AugmentationNode) augNode).childByArg(childName);
- if (enumNode instanceof LeafNode) {
- final Object value = enumNode.body();
- if (value instanceof String) {
- return (String) value;
- }
- }
- }
- return null;
+ return data.childByArg(childName) instanceof LeafNode<?> leafNode && leafNode.body() instanceof String str
+ ? str : null;
}
/**
Futures.addCallback(future, new FutureCallback<DOMRpcResult>() {
@Override
public void onSuccess(final DOMRpcResult response) {
- final var errors = response.getErrors();
+ final var errors = response.errors();
if (!errors.isEmpty()) {
- LOG.debug("RpcError message {}", response.getErrors());
- ar.resume(new RestconfDocumentedException("RPCerror message ", null, response.getErrors()));
+ LOG.debug("RpcError message {}", response.errors());
+ ar.resume(new RestconfDocumentedException("RPCerror message ", null, response.errors()));
return;
}
- final NormalizedNode resultData = response.getResult();
- if (resultData == null || ((ContainerNode) resultData).isEmpty()) {
+ final ContainerNode resultData = response.value();
+ if (resultData == null || resultData.isEmpty()) {
ar.resume(new WebApplicationException(Status.NO_CONTENT));
} else {
ar.resume(NormalizedNodePayload.of(context, resultData));
Futures.addCallback(resultErrors, new FutureCallback<>() {
@Override
public void onSuccess(final DOMRpcResult result) {
- final Collection<? extends RpcError> errors = result.getErrors();
+ final Collection<? extends RpcError> errors = result.errors();
if (!allWarnings(errors)) {
Futures.whenAllComplete(discardAndUnlock()).run(
() -> commitResult.setException(toCommitFailedException(errors)),
Futures.addCallback(netconfService.commit(), new FutureCallback<DOMRpcResult>() {
@Override
public void onSuccess(final DOMRpcResult rpcResult) {
- final Collection<? extends RpcError> errors = rpcResult.getErrors();
+ final Collection<? extends RpcError> errors = rpcResult.errors();
if (errors.isEmpty()) {
Futures.whenAllComplete(netconfService.unlock()).run(
() -> commitResult.set(CommitInfo.empty()),
private final FutureCallback<DOMRpcResult> lockOperationCallback = new FutureCallback<>() {
@Override
public void onSuccess(final DOMRpcResult rpcResult) {
- if (rpcResult != null && allWarnings(rpcResult.getErrors())) {
+ if (rpcResult != null && allWarnings(rpcResult.errors())) {
isLocked = true;
}
}
operationFuture = Futures.transformAsync(resultsFutures.get(0),
result -> {
// ... then add new operation to the chain if lock was successful
- if (result != null && (result.getErrors().isEmpty() || allWarnings(result.getErrors()))) {
+ if (result != null && (result.errors().isEmpty() || allWarnings(result.errors()))) {
return operation.get();
} else {
return Futures.immediateFailedFuture(new NetconfDocumentedException("Lock operation failed",
final var builder = ImmutableList.<RpcError>builder();
for (ListenableFuture<? extends DOMRpcResult> future : futures) {
- builder.addAll(Futures.getDone(future).getErrors());
+ builder.addAll(Futures.getDone(future).errors());
}
return new DefaultDOMRpcResult(null, builder.build());
}, MoreExecutors.directExecutor());
Futures.addCallback(operationResult, new FutureCallback<DOMRpcResult>() {
@Override
public void onSuccess(final DOMRpcResult rpcResult) {
- if (rpcResult != null && !rpcResult.getErrors().isEmpty()) {
+ if (rpcResult != null && !rpcResult.errors().isEmpty()) {
LOG.error("Errors occurred during processing of the RPC operation: {}",
- rpcResult.getErrors().stream().map(Object::toString).collect(Collectors.joining(",")));
+ rpcResult.errors().stream().map(Object::toString).collect(Collectors.joining(",")));
}
}
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public static DataSchemaNode checkListAndOrderedType(final EffectiveModelContext ctx,
final YangInstanceIdentifier path) {
final YangInstanceIdentifier parent = path.getParent();
- final DataSchemaContextNode<?> node = DataSchemaContextTree.from(ctx).findChild(parent).orElseThrow();
- final DataSchemaNode dataSchemaNode = node.getDataSchemaNode();
+ final DataSchemaContext node = DataSchemaContextTree.from(ctx).findChild(parent).orElseThrow();
+ final DataSchemaNode dataSchemaNode = node.dataSchemaNode();
if (dataSchemaNode instanceof ListSchemaNode) {
if (!((ListSchemaNode) dataSchemaNode).isUserOrdered()) {
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
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.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.builder.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
buildCont(builder, container.body(), ctxNode, trim);
return builder.build();
} else if (readData instanceof MapEntryNode mapEntry) {
- if (!(ctxNode.getDataSchemaNode() instanceof ListSchemaNode listSchema)) {
+ if (!(ctxNode.dataSchemaNode() instanceof ListSchemaNode listSchema)) {
throw new IllegalStateException("Input " + mapEntry + " does not match " + ctxNode);
}
private static void buildMapEntryBuilder(
final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder,
- final Collection<@NonNull DataContainerChild> children, final DataSchemaContextNode<?> ctxNode,
+ final Collection<@NonNull DataContainerChild> children, final DataSchemaContext ctxNode,
final boolean trim, final List<QName> keys) {
for (var child : children) {
final var childCtx = getChildContext(ctxNode, child);
}
private static void appendContainer(final DataContainerNodeBuilder<?, ?> builder, final ContainerNode container,
- final DataSchemaContextNode<?> ctxNode, final boolean trim) {
+ final DataSchemaContext ctxNode, final boolean trim) {
final var childBuilder = Builders.containerBuilder().withNodeIdentifier(container.getIdentifier());
buildCont(childBuilder, container.body(), ctxNode, trim);
builder.withChild(childBuilder.build());
}
private static void appendLeaf(final DataContainerNodeBuilder<?, ?> builder, final LeafNode<?> leaf,
- final DataSchemaContextNode<?> ctxNode, final boolean trim, final List<QName> keys) {
- if (!(ctxNode.getDataSchemaNode() instanceof LeafSchemaNode leafSchema)) {
+ final DataSchemaContext ctxNode, final boolean trim, final List<QName> keys) {
+ if (!(ctxNode.dataSchemaNode() instanceof LeafSchemaNode leafSchema)) {
throw new IllegalStateException("Input " + leaf + " does not match " + ctxNode);
}
}
private static void appendMap(final DataContainerNodeBuilder<?, ?> builder, final MapNode map,
- final DataSchemaContextNode<?> childCtx, final boolean trim) {
- if (!(childCtx.getDataSchemaNode() instanceof ListSchemaNode listSchema)) {
+ final DataSchemaContext childCtx, final boolean trim) {
+ if (!(childCtx.dataSchemaNode() instanceof ListSchemaNode listSchema)) {
throw new IllegalStateException("Input " + map + " does not match " + childCtx);
}
}
private static void buildList(final CollectionNodeBuilder<MapEntryNode, ? extends MapNode> builder,
- final Collection<@NonNull MapEntryNode> entries, final DataSchemaContextNode<?> ctxNode, final boolean trim,
+ final Collection<@NonNull MapEntryNode> entries, final DataSchemaContext ctxNode, final boolean trim,
final List<@NonNull QName> keys) {
for (var entry : entries) {
final var childCtx = getChildContext(ctxNode, entry);
}
private static void buildCont(final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builder,
- final Collection<DataContainerChild> children, final DataSchemaContextNode<?> ctxNode, final boolean trim) {
+ final Collection<DataContainerChild> children, final DataSchemaContext ctxNode, final boolean trim) {
for (var child : children) {
final var childCtx = getChildContext(ctxNode, child);
if (child instanceof ContainerNode container) {
}
}
- private static @NonNull DataSchemaContextNode<?> getChildContext(final DataSchemaContextNode<?> ctxNode,
+ private static @NonNull DataSchemaContext getChildContext(final DataSchemaContext ctxNode,
final NormalizedNode child) {
- final var childId = child.getIdentifier();
- final var childCtx = ctxNode.getChild(childId);
+ final var childId = child.name();
+ final var childCtx = ctxNode instanceof DataSchemaContext.Composite composite ? composite.childByArg(childId)
+ : null;
if (childCtx == null) {
throw new NoSuchElementException("Cannot resolve child " + childId + " in " + ctxNode);
}
mapValueToBuilder(
((ContainerNode) configDataNode).body(), ((ContainerNode) stateDataNode).body(), builder);
- return builder.build();
- } else if (configDataNode instanceof AugmentationNode) {
- final DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> builder = Builders
- .augmentationBuilder().withNodeIdentifier(((AugmentationNode) configDataNode).getIdentifier());
-
- mapValueToBuilder(((AugmentationNode) configDataNode).body(),
- ((AugmentationNode) stateDataNode).body(), builder);
-
return builder.build();
} else if (configDataNode instanceof ChoiceNode) {
final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> builder = Builders
import static java.util.Objects.requireNonNull;
import java.util.ArrayDeque;
+import java.util.ArrayList;
import java.util.Collection;
+import java.util.Comparator;
import java.util.Deque;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
import org.opendaylight.yangtools.yang.data.tree.api.ModificationType;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
final boolean serializeLeafNodesOnly(final Deque<PathArgument> path, final DataTreeCandidateNode candidate,
final boolean skipData, final boolean changedLeafNodesOnly) throws T {
- final var node = switch (candidate.getModificationType()) {
+ final var node = switch (candidate.modificationType()) {
case SUBTREE_MODIFIED, APPEARED -> candidate.getDataAfter().orElseThrow();
case DELETE, DISAPPEARED -> candidate.getDataBefore().orElseThrow();
case WRITE -> changedLeafNodesOnly && isNotUpdate(candidate) ? null
return true;
}
+ // Retain a modicum of sanity here: children may come from different namespaces. Report children from the same
+ // namespace first, holding others back. Once that is done, sort the remaining children by their PathArgument
+ // and report them in that order.
+ final var myNamespace = node.name().getNodeType().getModule();
+ final var heldBack = new ArrayList<DataTreeCandidateNode>();
boolean ret = false;
- for (var childNode : candidate.getChildNodes()) {
- path.add(childNode.getIdentifier());
- ret |= serializeLeafNodesOnly(path, childNode, skipData, changedLeafNodesOnly);
- path.removeLast();
+ for (var childNode : candidate.childNodes()) {
+ final var childName = childNode.name();
+ if (myNamespace.equals(childName.getNodeType().getModule())) {
+ ret |= serializeChild(path, childNode, skipData, changedLeafNodesOnly);
+ } else {
+ heldBack.add(childNode);
+ }
+ }
+ if (!heldBack.isEmpty()) {
+ // This is not exactly nice, as we really should be using schema definition order, but we do not have it
+ // available here, so we fall back to the next best thing.
+ heldBack.sort(Comparator.comparing(DataTreeCandidateNode::name));
+ for (var childNode : heldBack) {
+ ret |= serializeChild(path, childNode, skipData, changedLeafNodesOnly);
+ }
}
return ret;
}
+ private boolean serializeChild(final Deque<PathArgument> path, final DataTreeCandidateNode childNode,
+ final boolean skipData, final boolean changedLeafNodesOnly) throws T {
+ final boolean ret;
+ path.add(childNode.name());
+ ret = serializeLeafNodesOnly(path, childNode, skipData, changedLeafNodesOnly);
+ path.removeLast();
+ return ret;
+ }
+
private void serializeData(final Collection<PathArgument> dataPath, final DataTreeCandidateNode candidate,
final boolean skipData) throws T {
var stack = SchemaInferenceStack.of(context);
- var current = DataSchemaContextTree.from(context).getRoot();
+ DataSchemaContext current = DataSchemaContextTree.from(context).getRoot();
for (var arg : dataPath) {
- final var next = verifyNotNull(current.enterChild(stack, arg),
- "Failed to resolve %s: cannot find %s in %s", dataPath, arg, current);
- current = next;
+ final var next = current instanceof DataSchemaContext.Composite composite ? composite.enterChild(stack, arg)
+ : null;
+ current = verifyNotNull(next, "Failed to resolve %s: cannot find %s in %s", dataPath, arg, current);
}
// Exit to parent if needed
final StringBuilder pathBuilder = new StringBuilder();
for (var pathArgument : path) {
- if (pathArgument instanceof AugmentationIdentifier) {
- continue;
- }
pathBuilder.append('/');
pathBuilder.append(pathArgument.getNodeType().getNamespace().toString().replace(':', '-'));
pathBuilder.append(':');
@Override
void serializeOperation(final DataTreeCandidateNode candidate)
throws IOException {
- jsonWriter.name("operation").value(modificationTypeToOperation(candidate, candidate.getModificationType()));
+ jsonWriter.name("operation").value(modificationTypeToOperation(candidate, candidate.modificationType()));
}
@Override
@Override
public void serializeOperation(final DataTreeCandidateNode candidate) throws XMLStreamException {
xmlWriter.writeStartElement("operation");
- xmlWriter.writeCharacters(modificationTypeToOperation(candidate, candidate.getModificationType()));
+ xmlWriter.writeCharacters(modificationTypeToOperation(candidate, candidate.modificationType()));
xmlWriter.writeEndElement();
}
}
import org.opendaylight.restconf.api.query.FieldsParam.NodeSelector;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
+import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext.PathMixin;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
*/
public final class NetconfFieldsTranslator {
/**
- * {@link DataSchemaContextNode} of data element grouped with identifiers of leading mixin nodes and previous
- * path element.<br>
+ * {@link DataSchemaContext} of data element grouped with identifiers of leading mixin nodes and previous path
+ * element.<br>
* - identifiers of mixin nodes on the path to the target node - required for construction of full valid
* DOM paths,<br>
* - {@link LinkedPathElement} of the previous non-mixin node - required to successfully create a chain
private record LinkedPathElement(
@Nullable LinkedPathElement parentPathElement,
@NonNull List<PathArgument> mixinNodesToTarget,
- @NonNull DataSchemaContextNode<?> targetNode) {
+ @NonNull DataSchemaContext targetNode) {
LinkedPathElement {
requireNonNull(mixinNodesToTarget);
requireNonNull(targetNode);
private static @NonNull Set<LinkedPathElement> parseFields(final @NonNull InstanceIdentifierContext identifier,
final @NonNull FieldsParam input) {
- final var startNode = DataSchemaContextNode.fromDataSchemaNode((DataSchemaNode) identifier.getSchemaNode());
- if (startNode == null) {
+ final DataSchemaContext startNode;
+ try {
+ startNode = DataSchemaContext.of((DataSchemaNode) identifier.getSchemaNode());
+ } catch (IllegalStateException e) {
throw new RestconfDocumentedException(
- "Start node missing in " + input, ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
+ "Start node missing in " + input, ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE, e);
}
final var parsed = new HashSet<LinkedPathElement>();
final QName childQName) {
final var collectedMixinNodes = new ArrayList<PathArgument>();
- DataSchemaContextNode<?> currentNode = currentElement.targetNode;
- DataSchemaContextNode<?> actualContextNode = currentNode.getChild(childQName);
+ DataSchemaContext currentNode = currentElement.targetNode;
+ DataSchemaContext actualContextNode = childByQName(currentNode, childQName);
if (actualContextNode == null) {
- actualContextNode = resolveMixinNode(currentNode, currentNode.getIdentifier().getNodeType());
- actualContextNode = actualContextNode.getChild(childQName);
+ actualContextNode = resolveMixinNode(currentNode, currentNode.getPathStep().getNodeType());
+ actualContextNode = childByQName(actualContextNode, childQName);
}
- while (actualContextNode != null && actualContextNode.isMixin()) {
- final var actualDataSchemaNode = actualContextNode.getDataSchemaNode();
+ while (actualContextNode != null && actualContextNode instanceof PathMixin) {
+ final var actualDataSchemaNode = actualContextNode.dataSchemaNode();
if (actualDataSchemaNode instanceof ListSchemaNode listSchema && listSchema.getKeyDefinition().isEmpty()) {
// we need just a single node identifier from list in the path IFF it is an unkeyed list, otherwise
// we need both (which is the default case)
- actualContextNode = actualContextNode.getChild(childQName);
+ actualContextNode = childByQName(actualContextNode, childQName);
} else if (actualDataSchemaNode instanceof LeafListSchemaNode) {
// NodeWithValue is unusable - stop parsing
break;
} else {
- collectedMixinNodes.add(actualContextNode.getIdentifier());
- actualContextNode = actualContextNode.getChild(childQName);
+ collectedMixinNodes.add(actualContextNode.getPathStep());
+ actualContextNode = childByQName(actualContextNode, childQName);
}
}
if (actualContextNode == null) {
throw new RestconfDocumentedException("Child " + childQName.getLocalName() + " node missing in "
- + currentNode.getIdentifier().getNodeType().getLocalName(),
+ + currentNode.getPathStep().getNodeType().getLocalName(),
ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
return new LinkedPathElement(currentElement, collectedMixinNodes, actualContextNode);
}
+ private static @Nullable DataSchemaContext childByQName(final DataSchemaContext parent, final QName qname) {
+ return parent instanceof DataSchemaContext.Composite composite ? composite.childByQName(qname) : null;
+ }
+
private static YangInstanceIdentifier buildPath(final LinkedPathElement lastPathElement) {
LinkedPathElement pathElement = lastPathElement;
final var path = new LinkedList<PathArgument>();
do {
- path.addFirst(pathElement.targetNode.getIdentifier());
+ path.addFirst(contextPathArgument(pathElement.targetNode));
path.addAll(0, pathElement.mixinNodesToTarget);
pathElement = pathElement.parentPathElement;
} while (pathElement.parentPathElement != null);
- return YangInstanceIdentifier.create(path);
+ return YangInstanceIdentifier.of(path);
+ }
+
+ private static @NonNull PathArgument contextPathArgument(final DataSchemaContext context) {
+ final var arg = context.pathStep();
+ if (arg != null) {
+ return arg;
+ }
+
+ final var schema = context.dataSchemaNode();
+ if (schema instanceof ListSchemaNode listSchema && !listSchema.getKeyDefinition().isEmpty()) {
+ return NodeIdentifierWithPredicates.of(listSchema.getQName());
+ }
+ if (schema instanceof LeafListSchemaNode leafListSchema) {
+ return new NodeWithValue<>(leafListSchema.getQName(), Empty.value());
+ }
+ throw new UnsupportedOperationException("Unsupported schema " + schema);
}
- private static DataSchemaContextNode<?> resolveMixinNode(final DataSchemaContextNode<?> node,
+ private static DataSchemaContext resolveMixinNode(final DataSchemaContext node,
final @NonNull QName qualifiedName) {
- DataSchemaContextNode<?> currentNode = node;
- while (currentNode != null && currentNode.isMixin()) {
- currentNode = currentNode.getChild(qualifiedName);
+ DataSchemaContext currentNode = node;
+ while (currentNode != null && currentNode instanceof PathMixin currentMixin) {
+ currentNode = currentMixin.childByQName(qualifiedName);
}
return currentNode;
}
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext.PathMixin;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
*/
public static @NonNull List<Set<QName>> translate(final @NonNull InstanceIdentifierContext identifier,
final @NonNull FieldsParam input) {
- final DataSchemaContextNode<?> startNode = DataSchemaContextNode.fromDataSchemaNode(
- (DataSchemaNode) identifier.getSchemaNode());
+ final DataSchemaContext startNode = DataSchemaContext.of((DataSchemaNode) identifier.getSchemaNode());
if (startNode == null) {
throw new RestconfDocumentedException(
"Start node missing in " + input, ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
private static void processSelectors(final List<Set<QName>> parsed, final EffectiveModelContext context,
- final QNameModule startNamespace, final DataSchemaContextNode<?> startNode,
- final List<NodeSelector> selectors, final int index) {
+ final QNameModule startNamespace, final DataSchemaContext startNode, final List<NodeSelector> selectors,
+ final int index) {
final Set<QName> startLevel;
if (parsed.size() <= index) {
startLevel = new HashSet<>();
* @param level current nodes level
* @return {@link DataSchemaContextNode}
*/
- private static DataSchemaContextNode<?> addChildToResult(final DataSchemaContextNode<?> currentNode,
- final QName childQName, final Set<QName> level) {
+ private static DataSchemaContext addChildToResult(final DataSchemaContext currentNode, final QName childQName,
+ final Set<QName> level) {
// resolve parent node
- final DataSchemaContextNode<?> parentNode = resolveMixinNode(
- currentNode, level, currentNode.getIdentifier().getNodeType());
+ final var parentNode = resolveMixinNode(currentNode, level, currentNode.dataSchemaNode().getQName());
if (parentNode == null) {
throw new RestconfDocumentedException(
- "Not-mixin node missing in " + currentNode.getIdentifier().getNodeType().getLocalName(),
+ "Not-mixin node missing in " + currentNode.getPathStep().getNodeType().getLocalName(),
ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
// resolve child node
- final DataSchemaContextNode<?> childNode = resolveMixinNode(
- parentNode.getChild(childQName), level, childQName);
+ final DataSchemaContext childNode = resolveMixinNode(childByQName(parentNode, childQName), level, childQName);
if (childNode == null) {
throw new RestconfDocumentedException(
"Child " + childQName.getLocalName() + " node missing in "
- + currentNode.getIdentifier().getNodeType().getLocalName(),
+ + currentNode.getPathStep().getNodeType().getLocalName(),
ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
// add final childNode node to level nodes
- level.add(childNode.getIdentifier().getNodeType());
+ level.add(childNode.dataSchemaNode().getQName());
return childNode;
}
+ private static @Nullable DataSchemaContext childByQName(final DataSchemaContext parent, final QName qname) {
+ return parent instanceof DataSchemaContext.Composite composite ? composite.childByQName(qname) : null;
+ }
+
/**
* Resolve mixin node by searching for inner nodes until not mixin node or null is found.
* All nodes expect of not mixin node are added to current level nodes.
* @param qualifiedName qname of initial node
* @return {@link DataSchemaContextNode}
*/
- private static @Nullable DataSchemaContextNode<?> resolveMixinNode(final @Nullable DataSchemaContextNode<?> node,
+ private static @Nullable DataSchemaContext resolveMixinNode(final @Nullable DataSchemaContext node,
final @NonNull Set<QName> level, final @NonNull QName qualifiedName) {
- DataSchemaContextNode<?> currentNode = node;
- while (currentNode != null && currentNode.isMixin()) {
+ DataSchemaContext currentNode = node;
+ while (currentNode instanceof PathMixin currentMixin) {
level.add(qualifiedName);
- currentNode = currentNode.getChild(qualifiedName);
+ currentNode = currentMixin.childByQName(qualifiedName);
}
return currentNode;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext.PathMixin;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
final var path = new ArrayList<PathArgument>();
final SchemaNode node;
- var parentNode = DataSchemaContextTree.from(schemaContext).getRoot();
+ DataSchemaContext parentNode = DataSchemaContextTree.from(schemaContext).getRoot();
while (true) {
- final var parentSchema = parentNode.getDataSchemaNode();
- if (parentSchema instanceof ActionNodeContainer) {
- final var optAction = ((ActionNodeContainer) parentSchema).findAction(qname);
+ final var parentSchema = parentNode.dataSchemaNode();
+ if (parentSchema instanceof ActionNodeContainer actionParent) {
+ final var optAction = actionParent.findAction(qname);
if (optAction.isPresent()) {
if (it.hasNext()) {
throw new RestconfDocumentedException("Request path resolves to action '" + qname + "' and "
}
// Resolve the child step with respect to data schema tree
- final var found = RestconfDocumentedException.throwIfNull(parentNode.enterChild(stack, qname),
- ErrorType.PROTOCOL, ErrorTag.DATA_MISSING, "Schema for '%s' not found", qname);
+ final var found = RestconfDocumentedException.throwIfNull(
+ parentNode instanceof DataSchemaContext.Composite composite ? composite.enterChild(stack, qname) : null,
+ ErrorType.PROTOCOL, ErrorTag.DATA_MISSING, "Schema for '%s' not found", qname);
// Now add all mixins encountered to the path
var childNode = found;
- while (childNode.isMixin()) {
- path.add(childNode.getIdentifier());
- childNode = verifyNotNull(childNode.enterChild(stack, qname),
+ while (childNode instanceof PathMixin currentMixin) {
+ path.add(currentMixin.mixinPathStep());
+ childNode = verifyNotNull(currentMixin.enterChild(stack, qname),
"Mixin %s is missing child for %s while resolving %s", childNode, qname, found);
}
final PathArgument pathArg;
- if (step instanceof ListInstance) {
- final var values = ((ListInstance) step).keyValues();
- final var schema = childNode.getDataSchemaNode();
- pathArg = schema instanceof ListSchemaNode
- ? prepareNodeWithPredicates(stack, qname, (ListSchemaNode) schema, values)
+ if (step instanceof ListInstance listStep) {
+ final var values = listStep.keyValues();
+ final var schema = childNode.dataSchemaNode();
+ pathArg = schema instanceof ListSchemaNode listSchema
+ ? prepareNodeWithPredicates(stack, qname, listSchema, values)
: prepareNodeWithValue(stack, qname, schema, values);
} else {
- RestconfDocumentedException.throwIf(childNode.isKeyedEntry(),
+ RestconfDocumentedException.throwIf(childNode.dataSchemaNode() instanceof ListSchemaNode listChild
+ && !listChild.getKeyDefinition().isEmpty(),
ErrorType.PROTOCOL, ErrorTag.MISSING_ATTRIBUTE,
"Entry '%s' requires key or value predicate to be present.", qname);
- pathArg = childNode.getIdentifier();
+ pathArg = childNode.getPathStep();
}
path.add(pathArg);
if (!it.hasNext()) {
- node = childNode.getDataSchemaNode();
+ node = childNode.dataSchemaNode();
break;
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContext.PathMixin;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
* @return {@link String}
*/
public static String create(final EffectiveModelContext schemaContext, final YangInstanceIdentifier data) {
- final DataSchemaContextNode<?> current = DataSchemaContextTree.from(schemaContext).getRoot();
+ final DataSchemaContext current = DataSchemaContextTree.from(schemaContext).getRoot();
final MainVarsWrapper variables = new MainVarsWrapper(current);
final StringBuilder path = new StringBuilder();
QNameModule parentModule = null;
for (final PathArgument arg : data.getPathArguments()) {
// get module of the parent
- if (!variables.getCurrent().isMixin()) {
- parentModule = variables.getCurrent().getDataSchemaNode().getQName().getModule();
+ final var currentContext = variables.getCurrent();
+
+ if (!(currentContext instanceof PathMixin)) {
+ parentModule = currentContext.dataSchemaNode().getQName().getModule();
}
- variables.setCurrent(variables.getCurrent().getChild(arg));
- RestconfDocumentedException.throwIf(variables.getCurrent() == null, ErrorType.APPLICATION,
+ final var childContext = currentContext instanceof DataSchemaContext.Composite composite
+ ? composite.childByArg(arg) : null;
+
+ RestconfDocumentedException.throwIfNull(childContext, ErrorType.APPLICATION,
ErrorTag.UNKNOWN_ELEMENT, "Invalid input '%s': schema for argument '%s' (after '%s') not found",
data, arg, path);
- if (variables.getCurrent().isMixin()) {
+ variables.setCurrent(childContext);
+ if (childContext instanceof PathMixin) {
continue;
}
}
private static final class MainVarsWrapper {
+ private DataSchemaContext current;
- private DataSchemaContextNode<?> current;
-
- MainVarsWrapper(final DataSchemaContextNode<?> current) {
- this.setCurrent(current);
+ MainVarsWrapper(final DataSchemaContext current) {
+ setCurrent(current);
}
- public DataSchemaContextNode<?> getCurrent() {
+ public DataSchemaContext getCurrent() {
return current;
}
- public void setCurrent(final DataSchemaContextNode<?> current) {
+ public void setCurrent(final DataSchemaContext current) {
this.current = current;
}
-
}
}
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
}
}
- final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
+ final NormalizationResultHolder resultHolder = new NormalizationResultHolder();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
final XmlParserStream xmlParser = XmlParserStream.create(writer, iiContext.inference());
if (schemaNode instanceof ContainerSchemaNode || schemaNode instanceof ListSchemaNode) {
xmlParser.traverse(new DOMSource(doc.getDocumentElement()));
- return resultHolder.getResult();
+ return resultHolder.getResult().data();
}
// FIXME : add another DataSchemaNode extensions e.g. LeafSchemaNode
return null;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
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.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
XmlBodyReaderMountPointTest.class.getResourceAsStream("/invoke-rpc/xml/rpc-input.xml"));
checkNormalizedNodePayload(payload);
final ContainerNode contNode = (ContainerNode) payload.getData();
- final YangInstanceIdentifier yangCont = YangInstanceIdentifier.of(
- QName.create(contNode.getIdentifier().getNodeType(), "cont"));
- final ContainerNode contDataNode = (ContainerNode) contNode.getChildByArg(yangCont.getLastPathArgument());
- final YangInstanceIdentifier yangLeaf = YangInstanceIdentifier.of(
- QName.create(contDataNode.getIdentifier().getNodeType(), "lf"));
- final DataContainerChild leafDataNode = contDataNode.getChildByArg(yangLeaf.getLastPathArgument());
+ final ContainerNode contDataNode = (ContainerNode) contNode.getChildByArg(
+ new NodeIdentifier(QName.create(contNode.name().getNodeType(), "cont")));
+ final DataContainerChild leafDataNode = contDataNode.getChildByArg(
+ new NodeIdentifier(QName.create(contDataNode.name().getNodeType(), "lf")));
assertTrue("lf-test".equalsIgnoreCase(leafDataNode.body().toString()));
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import com.google.common.collect.Sets;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileNotFoundException;
.getDataChildByName(QName.create(INSTANCE_IDENTIFIER_MODULE_QNAME, "cont"));
final Module augmentModule = schemaContext.findModules(XMLNamespace.of("augment:module")).iterator().next();
final QName contAugmentQName = QName.create(augmentModule.getQNameModule(), "cont-augment");
- final YangInstanceIdentifier.AugmentationIdentifier augII = new YangInstanceIdentifier.AugmentationIdentifier(
- Sets.newHashSet(contAugmentQName));
- final YangInstanceIdentifier dataII = YangInstanceIdentifier.of(dataSchemaNode.getQName()).node(augII)
- .node(contAugmentQName);
+ final YangInstanceIdentifier dataII = YangInstanceIdentifier.of(dataSchemaNode.getQName(), contAugmentQName);
final String uri = "instance-identifier-module:cont";
mockBodyReader(uri, jsonBodyReader, true);
final NormalizedNodePayload payload = jsonBodyReader.readFrom(null, null, null, mediaType, null,
final QName augmentChoice1QName = QName.create(augmentModule.getQNameModule(), "augment-choice1");
final QName augmentChoice2QName = QName.create(augmentChoice1QName, "augment-choice2");
final QName containerQName = QName.create(augmentChoice1QName, "case-choice-case-container1");
- final YangInstanceIdentifier.AugmentationIdentifier augChoice1II =
- new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(augmentChoice1QName));
- final YangInstanceIdentifier.AugmentationIdentifier augChoice2II =
- new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(augmentChoice2QName));
- final YangInstanceIdentifier dataII = YangInstanceIdentifier.of(dataSchemaNode.getQName()).node(augChoice1II)
- .node(augmentChoice1QName).node(augChoice2II).node(augmentChoice2QName).node(containerQName);
+ final YangInstanceIdentifier dataII = YangInstanceIdentifier.of(dataSchemaNode.getQName())
+ .node(augmentChoice1QName).node(augmentChoice2QName).node(containerQName);
final String uri = "instance-identifier-module:cont";
mockBodyReader(uri, jsonBodyReader, true);
final NormalizedNodePayload payload = jsonBodyReader.readFrom(null, null, null, mediaType, null,
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.fail;
-import com.google.common.collect.Sets;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
-import java.util.Set;
import javax.ws.rs.core.MediaType;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
.getDataChildByName(QName.create(INSTANCE_IDENTIFIER_MODULE_QNAME, "cont"));
final Module augmentModule = schemaContext.findModules(XMLNamespace.of("augment:module")).iterator().next();
final QName contAugmentQName = QName.create(augmentModule.getQNameModule(), "cont-augment");
- final YangInstanceIdentifier.AugmentationIdentifier augII = new YangInstanceIdentifier.AugmentationIdentifier(
- Sets.newHashSet(contAugmentQName));
- final YangInstanceIdentifier dataII = YangInstanceIdentifier.of(dataSchemaNode.getQName()).node(augII)
- .node(contAugmentQName);
+ final YangInstanceIdentifier dataII = YangInstanceIdentifier.of(dataSchemaNode.getQName(), contAugmentQName);
final String uri = "instance-identifier-module:cont";
mockBodyReader(uri, xmlBodyReader, true);
final NormalizedNodePayload payload = xmlBodyReader.readFrom(null, null, null, mediaType, null,
final QName augmentChoice1QName = QName.create(augmentModule.getQNameModule(), "augment-choice1");
final QName augmentChoice2QName = QName.create(augmentChoice1QName, "augment-choice2");
final YangInstanceIdentifier dataII = YangInstanceIdentifier.of(dataSchemaNode.getQName())
- .node(new AugmentationIdentifier(Set.of(augmentChoice1QName)))
.node(augmentChoice1QName)
- // FIXME: DataSchemaContextTree bug? case children seem to ignore augments
- // .node(new AugmentationIdentifier(Set.of(augmentChoice2QName)))
.node(augmentChoice2QName)
.node(QName.create(augmentChoice1QName, "case-choice-case-container1"));
final String uri = "instance-identifier-module:cont";
final DOMRpcResult result = CreateStreamUtil.createDataChangeNotifiStream(
prepareDomPayload("create-data-change-event-subscription", RpcDefinition::getInput, "toaster", "path"),
SCHEMA_CTX);
- assertEquals(List.of(), result.getErrors());
- final NormalizedNode testedNn = result.getResult();
+ assertEquals(List.of(), result.errors());
+ final NormalizedNode testedNn = result.value();
assertNotNull(testedNn);
final NormalizedNodePayload contextRef = prepareDomPayload("create-data-change-event-subscription",
RpcDefinition::getOutput,
mock(RestconfStreamsSubscriptionService.class), actionService, new StreamsConfiguration(0, 1, 0, false));
final var nodeAndStack = DataSchemaContextTree.from(contextRef).enterPath(ACTION_YII).orElseThrow();
- final var node = nodeAndStack.node().getDataSchemaNode();
+ final var node = nodeAndStack.node().dataSchemaNode();
assertThat(node, instanceOf(ActionNodeContainer.class));
final var actionNode = ((ActionNodeContainer) node).findAction(RESET_QNAME).orElseThrow();
final var stack = nodeAndStack.stack();
final DOMRpcResult mockResult = new DefaultDOMRpcResult(OUTPUT, List.of());
doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(RPC, INPUT);
final DOMRpcResult rpcResult = RestconfInvokeOperationsServiceImpl.invokeRpc(INPUT, RPC, rpcService).get();
- assertTrue(rpcResult.getErrors().isEmpty());
- assertEquals(OUTPUT, rpcResult.getResult());
+ assertTrue(rpcResult.errors().isEmpty());
+ assertEquals(OUTPUT, rpcResult.value());
}
@Test
"No implementation of RPC " + errorRpc + " available.");
doReturn(immediateFailedFluentFuture(exception)).when(rpcService).invokeRpc(errorRpc, INPUT);
final DOMRpcResult rpcResult = RestconfInvokeOperationsServiceImpl.invokeRpc(INPUT, errorRpc, rpcService).get();
- assertNull(rpcResult.getResult());
- final Collection<? extends RpcError> errorList = rpcResult.getErrors();
+ assertNull(rpcResult.value());
+ final Collection<? extends RpcError> errorList = rpcResult.errors();
assertEquals(1, errorList.size());
final RpcError actual = errorList.iterator().next();
assertEquals("No implementation of RPC " + errorRpc + " available.", actual.getMessage());
final DOMRpcResult mockResult = new DefaultDOMRpcResult(OUTPUT, List.of());
doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(RPC, INPUT);
final DOMRpcResult rpcResult = RestconfInvokeOperationsServiceImpl.invokeRpc(INPUT, RPC, mountPoint).get();
- assertTrue(rpcResult.getErrors().isEmpty());
- assertEquals(OUTPUT, rpcResult.getResult());
+ assertTrue(rpcResult.errors().isEmpty());
+ assertEquals(OUTPUT, rpcResult.value());
}
@Test
doReturn(immediateFluentFuture(new DefaultDOMRpcResult(OUTPUT, List.of())))
.when(rpcService).invokeRpc(RPC, INPUT);
final DOMRpcResult rpcResult = RestconfInvokeOperationsServiceImpl.invokeRpc(INPUT, RPC, rpcService).get();
- assertTrue(rpcResult.getErrors().isEmpty());
- assertEquals(OUTPUT, rpcResult.getResult());
+ assertTrue(rpcResult.errors().isEmpty());
+ assertEquals(OUTPUT, rpcResult.value());
}
private NormalizedNodePayload prepNNC(final ContainerNode result) {
final ContainerNode data = mock(ContainerNode.class);
final DOMRpcResult domRpcResult = mock(DOMRpcResult.class);
doReturn(immediateFluentFuture(domRpcResult)).when(rpcService).invokeRpc(qname, data);
- doReturn(result).when(domRpcResult).getResult();
+ doReturn(result).when(domRpcResult).value();
return NormalizedNodePayload.of(
InstanceIdentifierContext.ofRpcInput(CONTEXT, schemaNode, null), data);
}
import static org.mockito.Mockito.when;
import java.time.Instant;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Set;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
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.LeafNode;
final DOMNotification notificationData = mock(DOMNotification.class);
final LeafNode<String> leaf = mockLeaf(QName.create(MODULE, "lf-augm"));
- final AugmentationNode augm = mockAugm(leaf);
- final ContainerNode notifiBody = mockCont(schemaPathNotifi.lastNodeIdentifier(), augm);
+ final ContainerNode notifiBody = mockCont(schemaPathNotifi.lastNodeIdentifier(), leaf);
when(notificationData.getType()).thenReturn(schemaPathNotifi);
when(notificationData.getBody()).thenReturn(notifiBody);
assertTrue(result.contains("lf-augm" + '"' + ":" + '"' + "value"));
}
- private static AugmentationNode mockAugm(final LeafNode<String> leaf) {
- final AugmentationNode augm = mock(AugmentationNode.class);
- final AugmentationIdentifier augmId = new AugmentationIdentifier(Set.of(leaf.getIdentifier().getNodeType()));
- when(augm.getIdentifier()).thenReturn(augmId);
-
- final Collection<DataContainerChild> childs = new ArrayList<>();
- childs.add(leaf);
-
- when(augm.body()).thenReturn(childs);
- return augm;
- }
-
private static MapEntryNode mockMapEntry(final QName entryQName, final LeafNode<String> leaf) {
return Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(entryQName, leaf.getIdentifier().getNodeType(),
- leaf.body()))
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(entryQName, leaf.name().getNodeType(), leaf.body()))
.withChild(leaf)
.build();
}
import static org.mockito.Mockito.when;
import java.time.Instant;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Set;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
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.LeafNode;
final DOMNotification notificationData = mock(DOMNotification.class);
final LeafNode<String> leaf = mockLeaf(QName.create(MODULE, "lf-augm"));
- final AugmentationNode augm = mockAugm(leaf);
- final ContainerNode notifiBody = mockCont(schemaPathNotifi.lastNodeIdentifier(), augm);
+ final ContainerNode notifiBody = mockCont(schemaPathNotifi.lastNodeIdentifier(), leaf);
when(notificationData.getType()).thenReturn(schemaPathNotifi);
when(notificationData.getBody()).thenReturn(notifiBody);
.areSimilar();
}
- private static AugmentationNode mockAugm(final LeafNode<String> leaf) {
- final AugmentationNode augm = mock(AugmentationNode.class);
- final AugmentationIdentifier augmId = new AugmentationIdentifier(Set.of(leaf.getIdentifier().getNodeType()));
- when(augm.getIdentifier()).thenReturn(augmId);
-
- final Collection<DataContainerChild> childs = new ArrayList<>();
- childs.add(leaf);
-
- when(augm.body()).thenReturn(childs);
- return augm;
- }
-
private static MapEntryNode mockMapEntry(final QName entryQName, final LeafNode<String> leaf) {
return Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(entryQName, leaf.getIdentifier().getNodeType(),
- leaf.body()))
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(entryQName, leaf.name().getNodeType(), leaf.body()))
.withChild(leaf)
.build();
}
*/
package org.opendaylight.restconf.nb.rfc8040.utils.parser;
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import java.util.List;
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
}
@Override
- protected void assertKeyedList(List<YangInstanceIdentifier> result) {
+ protected void assertKeyedList(final List<YangInstanceIdentifier> result) {
assertEquals(1, result.size());
}
protected void assertNamespace(final List<YangInstanceIdentifier> result) {
assertEquals(1, result.size());
final var augmentedLibraryPath = assertPath(result, AUGMENTED_LIBRARY_Q_NAME);
- assertEquals(2, augmentedLibraryPath.getPathArguments().size());
+ assertEquals(1, augmentedLibraryPath.getPathArguments().size());
}
@Override
assertEquals(1, result.size());
final var pathArguments = result.get(0).getPathArguments();
- assertEquals(3, pathArguments.size());
+ assertEquals(2, pathArguments.size());
assertEquals(PLAYER_Q_NAME, pathArguments.get(0).getNodeType());
- assertThat(pathArguments.get(1), instanceOf(AugmentationIdentifier.class));
- assertEquals(SPEED_Q_NAME, pathArguments.get(2).getNodeType());
+ assertEquals(SPEED_Q_NAME, pathArguments.get(1).getNodeType());
}
@Override
"/(parser:identifier:included?revision=2016-06-02)list-1/list-1"
+ "[{(parser:identifier:included?revision=2016-06-02)name=name, "
+ "(parser:identifier:included?revision=2016-06-02)revision=2016-06-02}]"
- + "/AugmentationIdentifier{childNames=[(parser:identifier?revision=2016-06-02)augment-leaf]}/"
- + "(parser:identifier?revision=2016-06-02)augment-leaf";
+ + "/(parser:identifier?revision=2016-06-02)augment-leaf";
// invalid test identifier
private static final String INVALID_TEST_IDENT =
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint8;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
final List<PathArgument> result = YangInstanceIdentifierDeserializer.create(SCHEMA_CONTEXT,
"deserializer-test-included:augmented-list=100/deserializer-test:augmented-leaf")
.path.getPathArguments();
- assertEquals(4, result.size());
+ assertEquals(3, result.size());
// list
final QName list = QName.create("deserializer:test:included", "2016-06-06", "augmented-list");
result.get(1));
// augmented leaf
- final QName augLeaf = QName.create("deserializer:test", "2016-06-06", "augmented-leaf");
- final QName augList = QName.create("deserializer:test", "2016-06-06", "augmenting-list");
- assertEquals(new AugmentationIdentifier(Set.of(augLeaf, augList)), result.get(2));
- assertEquals(NodeIdentifier.create(augLeaf), result.get(3));
+ assertEquals(NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "augmented-leaf")),
+ result.get(2));
}
@Test
final List<PathArgument> result = YangInstanceIdentifierDeserializer.create(SCHEMA_CONTEXT,
"deserializer-test-included:augmented-list=100/deserializer-test:augmenting-list=0")
.path.getPathArguments();
- assertEquals(5, result.size());
+ assertEquals(4, result.size());
// list
final QName list = QName.create("deserializer:test:included", "2016-06-06", "augmented-list");
result.get(1));
// augmented list
- final QName augLeaf = QName.create("deserializer:test", "2016-06-06", "augmented-leaf");
final QName augList = QName.create("deserializer:test", "2016-06-06", "augmenting-list");
- assertEquals(new AugmentationIdentifier(Set.of(augLeaf, augList)), result.get(2));
- assertEquals(NodeIdentifier.create(augList), result.get(3));
- assertEquals(NodeIdentifierWithPredicates.of(augList, QName.create(augList, "id"), 0), result.get(4));
+ assertEquals(NodeIdentifier.create(augList), result.get(2));
+ assertEquals(NodeIdentifierWithPredicates.of(augList, QName.create(augList, "id"), 0), result.get(3));
}
/**
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
-import com.google.common.collect.ImmutableSet;
import java.util.LinkedHashMap;
import java.util.Map;
import org.junit.AfterClass;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
.node(list)
.node(NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100))
- .node(new AugmentationIdentifier(ImmutableSet.of(child)))
.node(child)
.build();
final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
.node(list)
.node(NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100))
- .node(new AugmentationIdentifier(ImmutableSet.of(child)))
.node(child)
.build();
<operation>created</operation>
</data-change-event>
<data-change-event>
- <path>
- /instance-identifier-patch-module:patch-cont/augment-instance-identifier-patch-module:patch-choice1/augment-instance-identifier-patch-module:case-leaf1
- </path>
+ <path>/instance-identifier-patch-module:patch-cont/augment-instance-identifier-patch-module:leaf1</path>
<data>
- <case-leaf1 xmlns="augment:instance:identifier:patch:module">ChoiceLeaf</case-leaf1>
+ <leaf1 xmlns="augment:instance:identifier:patch:module">AugmentLeaf</leaf1>
</data>
<operation>created</operation>
</data-change-event>
<data-change-event>
- <path>/instance-identifier-patch-module:patch-cont/augment-instance-identifier-patch-module:leaf1</path>
+ <path>
+ /instance-identifier-patch-module:patch-cont/augment-instance-identifier-patch-module:patch-choice1/augment-instance-identifier-patch-module:case-leaf1
+ </path>
<data>
- <leaf1 xmlns="augment:instance:identifier:patch:module">AugmentLeaf</leaf1>
+ <case-leaf1 xmlns="augment:instance:identifier:patch:module">ChoiceLeaf</case-leaf1>
</data>
<operation>created</operation>
</data-change-event>
</data-changed-notification>
-</notification>
\ No newline at end of file
+</notification>
<operation>created</operation>
</data-change-event>
<data-change-event>
- <path>
- /instance-identifier-patch-module:patch-cont/augment-instance-identifier-patch-module:patch-choice1/augment-instance-identifier-patch-module:case-leaf1
- </path>
+ <path>/instance-identifier-patch-module:patch-cont/augment-instance-identifier-patch-module:leaf1</path>
<data>
- <case-leaf1 xmlns="augment:instance:identifier:patch:module">ChoiceUpdate</case-leaf1>
+ <leaf1 xmlns="augment:instance:identifier:patch:module">AugmentLeaf</leaf1>
</data>
<operation>updated</operation>
</data-change-event>
<data-change-event>
- <path>/instance-identifier-patch-module:patch-cont/augment-instance-identifier-patch-module:leaf1</path>
+ <path>
+ /instance-identifier-patch-module:patch-cont/augment-instance-identifier-patch-module:patch-choice1/augment-instance-identifier-patch-module:case-leaf1
+ </path>
<data>
- <leaf1 xmlns="augment:instance:identifier:patch:module">AugmentLeaf</leaf1>
+ <case-leaf1 xmlns="augment:instance:identifier:patch:module">ChoiceUpdate</case-leaf1>
</data>
<operation>updated</operation>
</data-change-event>
</data-changed-notification>
-</notification>
\ No newline at end of file
+</notification>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
// create temp socket to get available port for test
socket = new ServerSocket(0);
- final var localAddress = IetfInetUtil.INSTANCE.ipAddressFor(InetAddress.getLoopbackAddress());
+ final var localAddress = IetfInetUtil.ipAddressFor(InetAddress.getLoopbackAddress());
final var localPort = new PortNumber(Uint16.valueOf(socket.getLocalPort()));
socket.close();
if (addr == null) {
return port == null ? null : new InetSocketAddress(portNum);
}
- return new InetSocketAddress(IetfInetUtil.INSTANCE.inetAddressFor(addr), portNum);
+ return new InetSocketAddress(IetfInetUtil.inetAddressFor(addr), portNum);
}
}
@Test
public void integrationTest() throws Exception {
// localhost address, so we do not leak things around
- final var loopbackAddr = IetfInetUtil.INSTANCE.ipAddressFor(InetAddress.getLoopbackAddress());
+ final var loopbackAddr = IetfInetUtil.ipAddressFor(InetAddress.getLoopbackAddress());
// Server-side config
doReturn(loopbackAddr).when(serverGrouping).getLocalAddress();
// create temp socket to get available port for test
socket = new ServerSocket(0);
- final var localAddress = IetfInetUtil.INSTANCE.ipAddressFor(InetAddress.getLoopbackAddress());
+ final var localAddress = IetfInetUtil.ipAddressFor(InetAddress.getLoopbackAddress());
final var localPort = new PortNumber(Uint16.valueOf(socket.getLocalPort()));
socket.close();
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>12.0.6</version>
+ <version>13.0.1</version>
<relativePath/>
</parent>
Code Review / netconf.git / commitdiff