<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
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.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
public final class DomListBuilder {
// Inner List Qname identifiers for yang model's 'name' and 'value'
}
private static MapNode buildInnerList(final int index, final int elements) {
- CollectionNodeBuilder<MapEntryNode, MapNode> innerList = ImmutableNodes.mapNodeBuilder(InnerList.QNAME);
+ CollectionNodeBuilder<MapEntryNode, SystemMapNode> innerList = ImmutableNodes.mapNodeBuilder(InnerList.QNAME);
final String itemStr = "Item-" + String.valueOf(index) + "-";
for (int i = 0; i < elements; i++) {
try (DOMDataTreeReadTransaction tx = domDataBroker.newReadOnlyTransaction()) {
for (int l = 0; l < outerListElem; l++) {
YangInstanceIdentifier yid = pid.node(NodeIdentifierWithPredicates.of(OuterList.QNAME, olId, l));
- FluentFuture<Optional<NormalizedNode<?, ?>>> submitFuture = tx.read(dsType, yid);
+ FluentFuture<Optional<NormalizedNode>> submitFuture = tx.read(dsType, yid);
try {
- Optional<NormalizedNode<?,?>> optionalDataObject = submitFuture.get();
+ Optional<NormalizedNode> optionalDataObject = submitFuture.get();
if (optionalDataObject != null && optionalDataObject.isPresent()) {
- NormalizedNode<?, ?> ret = optionalDataObject.get();
+ NormalizedNode ret = optionalDataObject.get();
LOG.trace("optionalDataObject is {}", ret);
txOk++;
} else {
try (DOMDataTreeReadTransaction tx = domDataBroker.newReadOnlyTransaction()) {
for (int l = 0; l < outerListElem; l++) {
YangInstanceIdentifier yid = pid.node(NodeIdentifierWithPredicates.of(OuterList.QNAME, olId, l));
- Optional<NormalizedNode<?,?>> optionalDataObject;
- FluentFuture<Optional<NormalizedNode<?, ?>>> submitFuture = tx.read(dsType, yid);
+ Optional<NormalizedNode> optionalDataObject;
+ FluentFuture<Optional<NormalizedNode>> submitFuture = tx.read(dsType, yid);
try {
optionalDataObject = submitFuture.get();
if (optionalDataObject != null && optionalDataObject.isPresent()) {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>dom-parent</artifactId>
- <version>7.0.6</version>
+ <version>8.0.0-SNAPSHOT</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<link>https://commons.apache.org/proper/commons-lang/javadocs/api-3.9/</link>
<link>https://commons.apache.org/proper/commons-codec/apidocs/</link>
- <link>https://www.javadoc.io/doc/org.opendaylight.odlparent/odlparent-docs/8.1.1/</link>
- <link>https://www.javadoc.io/doc/org.opendaylight.yangtools/yangtools-docs/6.0.5/</link>
- <link>https://www.javadoc.io/doc/org.opendaylight.mdsal/mdsal-docs/7.0.6/</link>
+ <link>https://www.javadoc.io/doc/org.opendaylight.odlparent/odlparent-docs/9.0.1/</link>
+ <link>https://www.javadoc.io/doc/org.opendaylight.yangtools/yangtools-docs/7.0.1/</link>
+ <link>https://www.javadoc.io/doc/org.opendaylight.mdsal/mdsal-docs/8.0.0-SNAPSHOT/</link>
</links>
<groups>
<group>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-clustering-test-app-${project.version}">
<feature name="odl-clustering-test-app" version="${project.version}">
- <feature version="[7,8)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[8,9)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-controller-blueprint-${project.version}">
<feature name="odl-controller-blueprint" version="${project.version}">
- <feature version="[6,7)">odl-yangtools-codec</feature>
- <feature version="[7,8)">odl-mdsal-binding-api</feature>
- <feature version="[7,8)">odl-mdsal-binding-runtime</feature>
- <feature version="[7,8)">odl-mdsal-dom-api</feature>
+ <feature version="[7,8)">odl-yangtools-codec</feature>
+ <feature version="[8,9)">odl-mdsal-binding-api</feature>
+ <feature version="[8,9)">odl-mdsal-binding-runtime</feature>
+ <feature version="[8,9)">odl-mdsal-dom-api</feature>
<bundle start-level="40">mvn:org.opendaylight.controller/blueprint/${project.version}</bundle>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-mdsal-${project.version}">
<feature name="odl-controller-broker-local" version="${project.version}">
- <feature version="[7,8)">odl-mdsal-dom</feature>
- <feature version="[7,8)">odl-mdsal-eos-binding</feature>
- <feature version="[7,8)">odl-mdsal-eos-dom</feature>
- <feature version="[7,8)">odl-mdsal-singleton-dom</feature>
+ <feature version="[8,9)">odl-mdsal-dom</feature>
+ <feature version="[8,9)">odl-mdsal-eos-binding</feature>
+ <feature version="[8,9)">odl-mdsal-eos-dom</feature>
+ <feature version="[8,9)">odl-mdsal-singleton-dom</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-controller-exp-netty-config">
<feature name="odl-controller-exp-netty-config">
- <feature version="[8,9)">odl-netty-4</feature>
+ <feature version="[9,10)">odl-netty-4</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-controller-mdsal-common-${project.version}">
<feature name="odl-controller-mdsal-common" version="${project.version}">
- <feature version="[7,8)">odl-mdsal-common</feature>
- <feature version="[7,8)">odl-mdsal-binding-runtime</feature>
+ <feature version="[8,9)">odl-mdsal-common</feature>
+ <feature version="[8,9)">odl-mdsal-binding-runtime</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-mdsal-${project.version}">
<feature name="odl-mdsal-broker" version="${project.version}">
- <feature version="[7,8)">odl-mdsal-singleton-dom</feature>
- <feature version="[7,8)">odl-mdsal-eos-binding</feature>
+ <feature version="[8,9)">odl-mdsal-singleton-dom</feature>
+ <feature version="[8,9)">odl-mdsal-eos-binding</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-controller-${project.version}">
<feature name="odl-mdsal-clustering-commons" version="${project.version}">
- <feature version="[8,9)">odl-apache-commons-lang3</feature>
- <feature version="[8,9)">odl-dropwizard-metrics</feature>
- <feature version="[8,9)">odl-servlet-api</feature>
- <feature version="[6,7)">odl-yangtools-data</feature>
- <feature version="[6,7)">odl-yangtools-codec</feature>
+ <feature version="[9,10)">odl-apache-commons-lang3</feature>
+ <feature version="[9,10)">odl-dropwizard-metrics</feature>
+ <feature version="[9,10)">odl-servlet-api</feature>
+ <feature version="[7,8)">odl-yangtools-data</feature>
+ <feature version="[7,8)">odl-yangtools-codec</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-controller-${project.version}">
<feature name="odl-mdsal-distributed-datastore" version="${project.version}">
- <feature version="[8,9)">odl-apache-commons-text</feature>
- <feature version="[6,7)">odl-yangtools-codec</feature>
- <feature version="[7,8)">odl-mdsal-eos-dom</feature>
- <feature version="[7,8)">odl-mdsal-dom-broker</feature>
- <feature version="[7,8)">odl-mdsal-binding-dom-adapter</feature>
+ <feature version="[9,10)">odl-apache-commons-text</feature>
+ <feature version="[7,8)">odl-yangtools-codec</feature>
+ <feature version="[8,9)">odl-mdsal-eos-dom</feature>
+ <feature version="[8,9)">odl-mdsal-dom-broker</feature>
+ <feature version="[8,9)">odl-mdsal-binding-dom-adapter</feature>
<configfile finalname="configuration/initial/akka.conf">
mvn:org.opendaylight.controller/sal-clustering-config/${project.version}/xml/akkaconf
</configfile>
mvn:org.opendaylight.controller/sal-clustering-config/${project.version}/cfg/datastore
</configfile>
</feature>
-</features>
\ No newline at end of file
+</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-mdsal-model-inventory-${project.version}">
<feature name="odl-mdsal-model-inventory" version="${project.version}">
- <feature version="[7,8)">odl-mdsal-model-rfc6991</feature>
+ <feature version="[8,9)">odl-mdsal-model-rfc6991</feature>
</feature>
</features>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-toaster-${project.version}">
<feature name="odl-toaster" version="${project.version}">
- <feature version="[7,8)">odl-mdsal-binding-runtime</feature>
+ <feature version="[8,9)">odl-mdsal-binding-runtime</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>7.0.6</version>
+ <version>8.0.0-SNAPSHOT</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>6.0.5</version>
+ <version>7.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>7.0.6</version>
+ <version>8.0.0-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
*/
package org.opendaylight.controller.blueprint.ext;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Strings;
+import com.google.common.collect.Iterables;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.URISyntaxException;
-import java.util.List;
+import java.util.Set;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaTreeInference;
+import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
import org.osgi.service.blueprint.container.ComponentDefinitionException;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;
bindingQName = BindingReflections.findQName(appConfigBindingClass);
}
- public NormalizedNode<?, ?> parseDataElement(final Element element, final DataSchemaNode dataSchema,
- final EffectiveModelContext schemaContext) throws XMLStreamException, IOException,
- ParserConfigurationException, SAXException, URISyntaxException {
+ public NormalizedNode parseDataElement(final Element element, final SchemaTreeInference dataSchema)
+ throws XMLStreamException, IOException, ParserConfigurationException, SAXException, URISyntaxException {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
- final XmlParserStream xmlParser = XmlParserStream.create(writer, schemaContext, dataSchema);
+ final XmlParserStream xmlParser = XmlParserStream.create(writer, dataSchema);
xmlParser.traverse(new DOMSource(element));
- final NormalizedNode<?, ?> result = resultHolder.getResult();
+ final NormalizedNode result = resultHolder.getResult();
if (result instanceof MapNode) {
final MapNode mapNode = (MapNode) result;
- final MapEntryNode mapEntryNode = mapNode.getValue().iterator().next();
+ final MapEntryNode mapEntryNode = mapNode.body().iterator().next();
return mapEntryNode;
}
return result;
}
- public abstract NormalizedNode<?, ?> newDefaultNode(DataSchemaNode dataSchema);
+ public abstract NormalizedNode newDefaultNode(SchemaTreeInference dataSchema);
/**
* BindingContext implementation for a container binding.
}
@Override
- public NormalizedNode<?, ?> newDefaultNode(final DataSchemaNode dataSchema) {
+ public NormalizedNode newDefaultNode(final SchemaTreeInference dataSchema) {
return ImmutableNodes.containerNode(bindingQName);
}
}
}
@Override
- public NormalizedNode<?, ?> newDefaultNode(final DataSchemaNode dataSchema) {
+ public NormalizedNode newDefaultNode(final SchemaTreeInference dataSchema) {
+ final SchemaTreeEffectiveStatement<?> stmt = Iterables.getLast(dataSchema.statementPath());
+
// We assume there's only one key for the list.
- List<QName> keys = ((ListSchemaNode)dataSchema).getKeyDefinition();
- Preconditions.checkArgument(keys.size() == 1, "Expected only 1 key for list %s", appConfigBindingClass);
- QName listKeyQName = keys.get(0);
+ final Set<QName> keys = stmt.findFirstEffectiveSubstatementArgument(KeyEffectiveStatement.class)
+ .orElseThrow();
+
+ checkArgument(keys.size() == 1, "Expected only 1 key for list %s", appConfigBindingClass);
+ QName listKeyQName = keys.iterator().next();
return ImmutableNodes.mapEntryBuilder(bindingQName, listKeyQName, appConfigListKeyValue).build();
}
}
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaTreeInference;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
@FunctionalInterface
public interface FallbackConfigProvider {
- NormalizedNode<?,?> get(EffectiveModelContext schemaContext, DataSchemaNode dataSchema) throws IOException,
- XMLStreamException, ParserConfigurationException, SAXException, URISyntaxException;
+ NormalizedNode get(SchemaTreeInference dataSchema)
+ throws IOException, XMLStreamException, ParserConfigurationException, SAXException, URISyntaxException;
}
@FunctionalInterface
public T createDefaultInstance() throws ConfigXMLReaderException, ParserConfigurationException, XMLStreamException,
IOException, SAXException, URISyntaxException {
- return createDefaultInstance((schemaContext, dataSchema) -> {
- throw new IllegalArgumentException("Failed to read XML "
- + "(not creating model from defaults as runtime would, for better clarity in tests)");
+ return createDefaultInstance(dataSchema -> {
+ throw new IllegalArgumentException(
+ "Failed to read XML (not creating model from defaults as runtime would, for better clarity in tests)");
});
}
checkNotNull(module, "%s: Could not obtain the module schema for namespace %s, revision %s",
logName, bindingContext.bindingQName.getNamespace(), bindingContext.bindingQName.getRevision());
- QName qname = bindingContext.bindingQName;
- DataSchemaNode dataSchema = module.findDataChildByName(qname).orElseThrow(
- () -> new ConfigXMLReaderException(logName + ": Could not obtain the schema for " + qname));
-
- checkNotNull(dataSchema, "%s: Could not obtain the schema for %s", logName, bindingContext.bindingQName);
+ final SchemaInferenceStack schemaStack = SchemaInferenceStack.of(schemaContext);
+ final SchemaTreeEffectiveStatement<?> dataSchema;
+ try {
+ dataSchema = schemaStack.enterSchemaTree(bindingContext.bindingQName);
+ } catch (IllegalArgumentException e) {
+ throw new ConfigXMLReaderException(
+ logName + ": Could not obtain the schema for " + bindingContext.bindingQName, e);
+ }
- checkCondition(bindingContext.schemaType.isAssignableFrom(dataSchema.getClass()),
+ checkCondition(bindingContext.schemaType.isInstance(dataSchema),
"%s: Expected schema type %s for %s but actual type is %s", logName,
bindingContext.schemaType, bindingContext.bindingQName, dataSchema.getClass());
- NormalizedNode<?, ?> dataNode = parsePossibleDefaultAppConfigXMLFile(schemaContext, dataSchema);
+ NormalizedNode dataNode = parsePossibleDefaultAppConfigXMLFile(schemaStack);
if (dataNode == null) {
- dataNode = fallback.get(schemaService.getGlobalContext(), dataSchema);
+ dataNode = fallback.get(schemaStack.toSchemaTreeInference());
}
DataObject appConfig = bindingSerializer.fromNormalizedNode(yangPath, dataNode).getValue();
}
}
- private NormalizedNode<?, ?> parsePossibleDefaultAppConfigXMLFile(final EffectiveModelContext schemaContext,
- final DataSchemaNode dataSchema) throws ConfigXMLReaderException {
-
+ private NormalizedNode parsePossibleDefaultAppConfigXMLFile(final SchemaInferenceStack schemaStack)
+ throws ConfigXMLReaderException {
String appConfigFileName = defaultAppConfigFileName;
if (Strings.isNullOrEmpty(appConfigFileName)) {
- String moduleName = findYangModuleName(bindingContext.bindingQName, schemaContext);
+ String moduleName = schemaStack.currentModule().argument().getLocalName();
+
appConfigFileName = moduleName + "_" + bindingContext.bindingQName.getLocalName() + ".xml";
}
URL url = optionalURL.get();
try (InputStream is = url.openStream()) {
Document root = UntrustedXML.newDocumentBuilder().parse(is);
- NormalizedNode<?, ?> dataNode = bindingContext.parseDataElement(root.getDocumentElement(), dataSchema,
- schemaContext);
+ NormalizedNode dataNode = bindingContext.parseDataElement(root.getDocumentElement(),
+ schemaStack.toSchemaTreeInference());
LOG.debug("{}: Parsed data node: {}", logName, dataNode);
throw new ConfigXMLReaderException(msg, e);
}
}
-
- private String findYangModuleName(final QName qname, final SchemaContext schemaContext)
- throws ConfigXMLReaderException {
- for (Module m : schemaContext.getModules()) {
- if (qname.getModule().equals(m.getQNameModule())) {
- return m.getName();
- }
- }
- throw new ConfigXMLReaderException(
- String.format("%s: Could not find yang module for QName %s", logName, qname));
- }
-
}
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaTreeInference;
import org.osgi.service.blueprint.container.ComponentDefinitionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
DataStoreAppConfigDefaultXMLReader<?> reader = new DataStoreAppConfigDefaultXMLReader<>(logName(),
defaultAppConfigFileName, getOSGiService(DOMSchemaService.class), bindingSerializer, bindingContext,
inputStreamProvider);
- return reader.createDefaultInstance((schemaContext, dataSchema) -> {
+ return reader.createDefaultInstance(dataSchema -> {
// Fallback if file cannot be read, try XML from Config
- NormalizedNode<?, ?> dataNode = parsePossibleDefaultAppConfigElement(schemaContext, dataSchema);
+ NormalizedNode dataNode = parsePossibleDefaultAppConfigElement(dataSchema);
if (dataNode == null) {
// or, as last resort, defaults from the model
return bindingContext.newDefaultNode(dataSchema);
}
}
- private @Nullable NormalizedNode<?, ?> parsePossibleDefaultAppConfigElement(
- final EffectiveModelContext schemaContext, final DataSchemaNode dataSchema) throws URISyntaxException,
- IOException, ParserConfigurationException, SAXException, XMLStreamException {
+ private @Nullable NormalizedNode parsePossibleDefaultAppConfigElement(final SchemaTreeInference dataSchema)
+ throws URISyntaxException, IOException, ParserConfigurationException, SAXException, XMLStreamException {
if (defaultAppConfigElement == null) {
return null;
}
LOG.debug("{}: Got app config schema: {}", logName(), dataSchema);
- NormalizedNode<?, ?> dataNode = bindingContext.parseDataElement(defaultAppConfigElement, dataSchema,
- schemaContext);
+ NormalizedNode dataNode = bindingContext.parseDataElement(defaultAppConfigElement, dataSchema);
LOG.debug("{}: Parsed data node: {}", logName(), dataNode);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
public final class ReadTransactionSuccess extends TransactionSuccess<ReadTransactionSuccess>
implements SliceableMessage {
private static final long serialVersionUID = 1L;
- private final Optional<NormalizedNode<?, ?>> data;
+ private final Optional<NormalizedNode> data;
public ReadTransactionSuccess(final TransactionIdentifier identifier, final long sequence,
- final Optional<NormalizedNode<?, ?>> data) {
+ final Optional<NormalizedNode> data) {
super(identifier, sequence);
this.data = requireNonNull(data);
}
- public Optional<NormalizedNode<?, ?>> getData() {
+ public Optional<NormalizedNode> getData() {
return data;
}
final class ReadTransactionSuccessProxyV1 extends AbstractTransactionSuccessProxy<ReadTransactionSuccess> {
private static final long serialVersionUID = 1L;
- private Optional<NormalizedNode<?, ?>> data;
+ private Optional<NormalizedNode> data;
private transient NormalizedNodeStreamVersion streamVersion;
// checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
*/
@Beta
public abstract class TransactionDataModification extends TransactionModification {
- private final NormalizedNode<?, ?> data;
+ private final NormalizedNode data;
- TransactionDataModification(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ TransactionDataModification(final YangInstanceIdentifier path, final NormalizedNode data) {
super(path);
this.data = requireNonNull(data);
}
- public final NormalizedNode<?, ?> getData() {
+ public final NormalizedNode getData() {
return data;
}
*/
@Beta
public final class TransactionMerge extends TransactionDataModification {
- public TransactionMerge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public TransactionMerge(final YangInstanceIdentifier path, final NormalizedNode data) {
super(path, data);
}
*/
@Beta
public final class TransactionWrite extends TransactionDataModification {
- public TransactionWrite(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public TransactionWrite(final YangInstanceIdentifier path, final NormalizedNode data) {
super(path, data);
}
package org.opendaylight.controller.cluster.access.commands;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.testkit.TestActors;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
private final TransactionIdentifier transactionIdentifier =
new TransactionIdentifier(new LocalHistoryIdentifier(clientId, 0L), 0L);
private final ActorRef actorRef = ActorSystem.create("test").actorOf(Props.create(TestActors.EchoActor.class));
- private final NormalizedNode<?, ?> node = Builders.containerBuilder().withNodeIdentifier(
+ private final NormalizedNode node = Builders.containerBuilder().withNodeIdentifier(
YangInstanceIdentifier.NodeIdentifier.create(QName.create("namespace", "localName"))).build();
private final TransactionModification transactionModification =
new TransactionWrite(YangInstanceIdentifier.empty(), node);
@Test
public void testGetIdentifier() {
final TransactionIdentifier identifier = modifyTransactionRequestBuilder.getIdentifier();
- Assert.assertEquals(transactionIdentifier, identifier);
+ assertEquals(transactionIdentifier, identifier);
}
@Test
public void testBuildReady() {
modifyTransactionRequestBuilder.setReady();
final ModifyTransactionRequest modifyTransactionRequest = modifyTransactionRequestBuilder.build();
- Assert.assertEquals(PersistenceProtocol.READY, modifyTransactionRequest.getPersistenceProtocol().get());
- Assert.assertEquals(transactionModification, modifyTransactionRequest.getModifications().get(0));
+ assertEquals(PersistenceProtocol.READY, modifyTransactionRequest.getPersistenceProtocol().get());
+ assertEquals(transactionModification, modifyTransactionRequest.getModifications().get(0));
}
@Test
public void testBuildAbort() {
modifyTransactionRequestBuilder.setAbort();
final ModifyTransactionRequest modifyTransactionRequest = modifyTransactionRequestBuilder.build();
- Assert.assertEquals(PersistenceProtocol.ABORT, modifyTransactionRequest.getPersistenceProtocol().get());
- Assert.assertTrue(modifyTransactionRequest.getModifications().isEmpty());
+ assertEquals(PersistenceProtocol.ABORT, modifyTransactionRequest.getPersistenceProtocol().get());
+ assertTrue(modifyTransactionRequest.getModifications().isEmpty());
}
@Test
public void testBuildCommitTrue() {
modifyTransactionRequestBuilder.setCommit(true);
final ModifyTransactionRequest modifyTransactionRequest = modifyTransactionRequestBuilder.build();
- Assert.assertEquals(PersistenceProtocol.THREE_PHASE, modifyTransactionRequest.getPersistenceProtocol().get());
+ assertEquals(PersistenceProtocol.THREE_PHASE, modifyTransactionRequest.getPersistenceProtocol().get());
}
@Test
public void testBuildCommitFalse() {
modifyTransactionRequestBuilder.setCommit(false);
final ModifyTransactionRequest modifyTransactionRequest = modifyTransactionRequestBuilder.build();
- Assert.assertEquals(PersistenceProtocol.SIMPLE, modifyTransactionRequest.getPersistenceProtocol().get());
+ assertEquals(PersistenceProtocol.SIMPLE, modifyTransactionRequest.getPersistenceProtocol().get());
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.opendaylight.controller.cluster.access.commands.TransactionModification.TYPE_WRITE;
import com.google.common.base.MoreObjects;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
public class ModifyTransactionRequestTest extends AbstractTransactionRequestTest<ModifyTransactionRequest> {
- private static final NormalizedNode<?, ?> NODE = Builders.containerBuilder().withNodeIdentifier(
- YangInstanceIdentifier.NodeIdentifier.create(QName.create("namespace", "localName"))).build();
+ private static final ContainerNode NODE = Builders.containerBuilder().withNodeIdentifier(
+ NodeIdentifier.create(QName.create("namespace", "localName"))).build();
private static final List<TransactionModification> MODIFICATIONS = Lists.newArrayList(
new TransactionWrite(YangInstanceIdentifier.empty(), NODE));
@Test
public void getPersistenceProtocolTest() {
final Optional<PersistenceProtocol> result = OBJECT.getPersistenceProtocol();
- Assert.assertTrue(result.isPresent());
- Assert.assertEquals(PROTOCOL, result.get());
+ assertTrue(result.isPresent());
+ assertEquals(PROTOCOL, result.get());
}
@Test
public void getModificationsTest() {
final List<TransactionModification> result = OBJECT.getModifications();
- Assert.assertNotNull(result);
- Assert.assertEquals(MODIFICATIONS, result);
+ assertNotNull(result);
+ assertEquals(MODIFICATIONS, result);
}
@Test
public void addToStringAttributesTest() {
final MoreObjects.ToStringHelper result = OBJECT.addToStringAttributes(MoreObjects.toStringHelper(OBJECT));
- Assert.assertTrue(result.toString().contains("modifications=1"));
- Assert.assertTrue(result.toString().contains("protocol=" + PROTOCOL));
+ assertTrue(result.toString().contains("modifications=1"));
+ assertTrue(result.toString().contains("protocol=" + PROTOCOL));
}
@Test
@Override
protected void doAdditionalAssertions(final Object deserialize) {
- Assert.assertTrue(deserialize instanceof ModifyTransactionRequest);
+ assertTrue(deserialize instanceof ModifyTransactionRequest);
final ModifyTransactionRequest casted = (ModifyTransactionRequest) deserialize;
- Assert.assertEquals(OBJECT.getReplyTo(), casted.getReplyTo());
- Assert.assertEquals(OBJECT.getPersistenceProtocol(), casted.getPersistenceProtocol());
+ assertEquals(OBJECT.getReplyTo(), casted.getReplyTo());
+ assertEquals(OBJECT.getPersistenceProtocol(), casted.getPersistenceProtocol());
- Assert.assertNotNull(casted.getModifications());
- Assert.assertEquals(1, casted.getModifications().size());
+ assertNotNull(casted.getModifications());
+ assertEquals(1, casted.getModifications().size());
final TransactionModification modification = casted.getModifications().get(0);
- Assert.assertEquals(YangInstanceIdentifier.empty(), modification.getPath());
- Assert.assertEquals(TYPE_WRITE, modification.getType());
+ assertEquals(YangInstanceIdentifier.empty(), modification.getPath());
+ assertEquals(TYPE_WRITE, modification.getType());
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
import java.util.Optional;
-import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@Test
public void getDataTest() {
- final Optional<NormalizedNode<?, ?>> result = OBJECT.getData();
- Assert.assertFalse(result.isPresent());
+ final Optional<NormalizedNode> result = OBJECT.getData();
+ assertFalse(result.isPresent());
}
@Test
public void cloneAsVersionTest() {
final ReadTransactionSuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- Assert.assertEquals(OBJECT, clone);
+ assertEquals(OBJECT, clone);
}
@Override
- protected void doAdditionalAssertions(Object deserialize) {
- Assert.assertTrue(deserialize instanceof ReadTransactionSuccess);
- Assert.assertEquals(OBJECT.getData(), ((ReadTransactionSuccess) deserialize).getData());
+ protected void doAdditionalAssertions(final Object deserialize) {
+ assertTrue(deserialize instanceof ReadTransactionSuccess);
+ assertEquals(OBJECT.getData(), ((ReadTransactionSuccess) deserialize).getData());
}
}
*/
package org.opendaylight.controller.cluster.access.commands;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
import java.util.Optional;
-import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.controller.cluster.access.ABIVersion;
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.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
public class ReadTransactionSuccessTest extends AbstractTransactionSuccessTest<ReadTransactionSuccess> {
- private static final NormalizedNode<?, ?> NODE = Builders.containerBuilder().withNodeIdentifier(
- YangInstanceIdentifier.NodeIdentifier.create(QName.create("namespace", "localName"))).build();
+ private static final ContainerNode NODE = Builders.containerBuilder().withNodeIdentifier(
+ NodeIdentifier.create(QName.create("namespace", "localName"))).build();
private static final ReadTransactionSuccess OBJECT = new ReadTransactionSuccess(
TRANSACTION_IDENTIFIER, 0, Optional.of(NODE));
@Test
public void getDataTest() {
- final Optional<NormalizedNode<?, ?>> result = OBJECT.getData();
- Assert.assertTrue(result.isPresent());
- Assert.assertEquals(NODE.getValue(), result.get().getValue());
+ final Optional<NormalizedNode> result = OBJECT.getData();
+ assertTrue(result.isPresent());
+ assertEquals(NODE.body(), result.get().body());
}
@Test
public void cloneAsVersionTest() {
final ReadTransactionSuccess clone = OBJECT.cloneAsVersion(ABIVersion.BORON);
- Assert.assertEquals(OBJECT, clone);
+ assertEquals(OBJECT, clone);
}
@Override
- protected void doAdditionalAssertions(Object deserialize) {
- Assert.assertTrue(deserialize instanceof ReadTransactionSuccess);
- Assert.assertEquals(OBJECT.getData(), ((ReadTransactionSuccess) deserialize).getData());
+ protected void doAdditionalAssertions(final Object deserialize) {
+ assertTrue(deserialize instanceof ReadTransactionSuccess);
+ assertEquals(OBJECT.getData(), ((ReadTransactionSuccess) deserialize).getData());
}
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>7.0.6</version>
+ <version>8.0.0-SNAPSHOT</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.apache.geronimo.specs</groupId>
<artifactId>geronimo-atinject_1.0_spec</artifactId>
- <version>1.0</version>
</dependency>
<dependency>
<groupId>org.apache.karaf.features</groupId>
<artifactId>org.apache.karaf.features.core</artifactId>
- <version>${karaf.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>7.0.6</version>
+ <version>8.0.0-SNAPSHOT</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
* Handles a message.
*
* @deprecated This method is not final for testing purposes. DO NOT OVERRIDE IT, override
- * {@link #handleNonRaftCommand(Object)} instead.
+ * {@link #handleNonRaftCommand(Object)} instead.
*/
@Deprecated
@Override
import akka.actor.PoisonPill;
import akka.actor.Status.Success;
import akka.cluster.Cluster;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
import java.io.File;
import java.io.FileInputStream;
-import java.net.URI;
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.cluster.admin.rev151013.shard.result.output.ShardResultKey;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
shardNames.add(s.getName());
}
- assertEquals("DatastoreSnapshot shard names", Sets.newHashSet(expShardNames), shardNames);
+ assertEquals("DatastoreSnapshot shard names", Set.of(expShardNames), shardNames);
}
@Test
verifyRaftPeersPresent(newReplicaNode2.operDataStore(), "cars", "member-1", "member-3");
// Write data to member-2's config datastore and read/verify via member-3
- final NormalizedNode<?, ?> configCarsNode = writeCarsNodeAndVerify(newReplicaNode2.configDataStore(),
+ final NormalizedNode configCarsNode = writeCarsNodeAndVerify(newReplicaNode2.configDataStore(),
newReplicaNode3.configDataStore());
// Write data to member-3's oper datastore and read/verify via member-2
verifyFailedRpcResult(rpcResult);
}
- private static NormalizedNode<?, ?> writeCarsNodeAndVerify(final AbstractDataStore writeToStore,
+ private static NormalizedNode writeCarsNodeAndVerify(final AbstractDataStore writeToStore,
final AbstractDataStore readFromStore) throws Exception {
DOMStoreWriteTransaction writeTx = writeToStore.newWriteOnlyTransaction();
- NormalizedNode<?, ?> carsNode = CarsModel.create();
+ NormalizedNode carsNode = CarsModel.create();
writeTx.write(CarsModel.BASE_PATH, carsNode);
DOMStoreThreePhaseCommitCohort cohort = writeTx.ready();
}
private static void readCarsNodeAndVerify(final AbstractDataStore readFromStore,
- final NormalizedNode<?, ?> expCarsNode) throws Exception {
- Optional<NormalizedNode<?, ?>> optional = readFromStore.newReadOnlyTransaction().read(CarsModel.BASE_PATH)
+ final NormalizedNode expCarsNode) throws Exception {
+ Optional<NormalizedNode> optional = readFromStore.newReadOnlyTransaction().read(CarsModel.BASE_PATH)
.get(15, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", expCarsNode, optional.get());
MemberNode leaderNode1 = MemberNode.builder(memberNodes).akkaConfig("Member1").testName(name)
.moduleShardsConfig(moduleShardsConfig).waitForShardLeader("cars", "people").build();
- ModuleShardConfiguration petsModuleConfig = new ModuleShardConfiguration(URI.create("pets-ns"), "pets-module",
- "pets", null,
- Collections.singletonList(MEMBER_1));
+ ModuleShardConfiguration petsModuleConfig = new ModuleShardConfiguration(
+ XMLNamespace.of("pets-ns"), "pets-module", "pets", null, List.of(MEMBER_1));
leaderNode1.configDataStore().getActorUtils().getShardManager().tell(
new CreateShard(petsModuleConfig, Shard.builder(), null), leaderNode1.kit().getRef());
leaderNode1.kit().expectMsgClass(Success.class);
newReplicaNode2.kit().expectMsgClass(Success.class);
newReplicaNode2.operDataStore().getActorUtils().getShardManager().tell(
- new CreateShard(new ModuleShardConfiguration(URI.create("no-leader-ns"), "no-leader-module",
- "no-leader", null,
- Collections.singletonList(MEMBER_1)),
+ new CreateShard(new ModuleShardConfiguration(XMLNamespace.of("no-leader-ns"), "no-leader-module",
+ "no-leader", null, List.of(MEMBER_1)),
Shard.builder(), null),
newReplicaNode2.kit().getRef());
newReplicaNode2.kit().expectMsgClass(Success.class);
verifyRaftPeersPresent(replicaNode2.configDataStore(), "cars", "member-1", "member-3");
verifyRaftPeersPresent(replicaNode3.configDataStore(), "cars", "member-1", "member-2");
- ModuleShardConfiguration petsModuleConfig = new ModuleShardConfiguration(URI.create("pets-ns"), "pets-module",
- "pets", null, Arrays.asList(MEMBER_1, MEMBER_2, MEMBER_3));
+ ModuleShardConfiguration petsModuleConfig = new ModuleShardConfiguration(XMLNamespace.of("pets-ns"),
+ "pets-module", "pets", null, List.of(MEMBER_1, MEMBER_2, MEMBER_3));
leaderNode1.configDataStore().getActorUtils().getShardManager().tell(
new CreateShard(petsModuleConfig, Shard.builder(), null), leaderNode1.kit().getRef());
leaderNode1.kit().expectMsgClass(Success.class);
RpcResult<ChangeMemberVotingStatesForShardOutput> rpcResult = service3
.changeMemberVotingStatesForShard(new ChangeMemberVotingStatesForShardInputBuilder()
.setShardName("cars").setDataStoreType(DataStoreType.Config)
- .setMemberVotingState(ImmutableList.of(
+ .setMemberVotingState(List.of(
new MemberVotingStateBuilder().setMemberName("member-2").setVoting(FALSE).build(),
new MemberVotingStateBuilder().setMemberName("member-3").setVoting(FALSE).build()))
.build())
RpcResult<ChangeMemberVotingStatesForShardOutput> rpcResult = service
.changeMemberVotingStatesForShard(new ChangeMemberVotingStatesForShardInputBuilder()
.setShardName("cars").setDataStoreType(DataStoreType.Config)
- .setMemberVotingState(ImmutableList
- .of(new MemberVotingStateBuilder().setMemberName("member-1").setVoting(FALSE).build()))
+ .setMemberVotingState(List.of(new MemberVotingStateBuilder()
+ .setMemberName("member-1")
+ .setVoting(FALSE)
+ .build()))
.build())
.get(10, TimeUnit.SECONDS);
verifyFailedRpcResult(rpcResult);
replicaNode3.operDataStore(), null);
RpcResult<ChangeMemberVotingStatesForAllShardsOutput> rpcResult = service3.changeMemberVotingStatesForAllShards(
- new ChangeMemberVotingStatesForAllShardsInputBuilder().setMemberVotingState(ImmutableList.of(
+ new ChangeMemberVotingStatesForAllShardsInputBuilder().setMemberVotingState(List.of(
new MemberVotingStateBuilder().setMemberName("member-2").setVoting(FALSE).build(),
new MemberVotingStateBuilder().setMemberName("member-3").setVoting(FALSE).build())).build())
.get(10, TimeUnit.SECONDS);
public void testFlipMemberVotingStates() throws Exception {
String name = "testFlipMemberVotingStates";
- ServerConfigurationPayload persistedServerConfig = new ServerConfigurationPayload(Arrays.asList(
+ ServerConfigurationPayload persistedServerConfig = new ServerConfigurationPayload(List.of(
new ServerInfo("member-1", true), new ServerInfo("member-2", true),
new ServerInfo("member-3", false)));
// Members 1, 2, and 3 are initially started up as non-voting. Members 4, 5, and 6 are initially
// non-voting and simulated as down by not starting them up.
- ServerConfigurationPayload persistedServerConfig = new ServerConfigurationPayload(Arrays.asList(
+ ServerConfigurationPayload persistedServerConfig = new ServerConfigurationPayload(List.of(
new ServerInfo("member-1", false), new ServerInfo("member-2", false),
new ServerInfo("member-3", false), new ServerInfo("member-4", true),
new ServerInfo("member-5", true), new ServerInfo("member-6", true)));
String name = "testFlipMemberVotingStatesWithVotingMembersDown";
// Members 4, 5, and 6 are initially non-voting and simulated as down by not starting them up.
- ServerConfigurationPayload persistedServerConfig = new ServerConfigurationPayload(Arrays.asList(
+ ServerConfigurationPayload persistedServerConfig = new ServerConfigurationPayload(List.of(
new ServerInfo("member-1", true), new ServerInfo("member-2", true),
new ServerInfo("member-3", true), new ServerInfo("member-4", false),
new ServerInfo("member-5", false), new ServerInfo("member-6", false)));
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-codec-binfmt</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-repo-spi</artifactId>
+ </dependency>
<!-- Compression -->
<dependency>
* NormalizedNodeNavigator walks a {@link NormalizedNodeVisitor} through the NormalizedNode.
*/
public class NormalizedNodeNavigator {
-
private final NormalizedNodeVisitor visitor;
public NormalizedNodeNavigator(final NormalizedNodeVisitor visitor) {
this.visitor = requireNonNull(visitor, "visitor should not be null");
}
- public void navigate(String parentPath, final NormalizedNode<?, ?> normalizedNode) {
+ public void navigate(String parentPath, final NormalizedNode normalizedNode) {
if (parentPath == null) {
parentPath = "";
}
}
private void navigateDataContainerNode(final int level, final String parentPath,
- final DataContainerNode<?> dataContainerNode) {
+ final DataContainerNode dataContainerNode) {
visitor.visitNode(level, parentPath, dataContainerNode);
String newParentPath = parentPath + "/" + dataContainerNode.getIdentifier().toString();
- for (NormalizedNode<?, ?> node : dataContainerNode.getValue()) {
+ for (NormalizedNode node : dataContainerNode.body()) {
if (node instanceof MixinNode && node instanceof NormalizedNodeContainer) {
- navigateNormalizedNodeContainerMixin(level, newParentPath, (NormalizedNodeContainer<?, ?, ?>) node);
+ navigateNormalizedNodeContainerMixin(level, newParentPath, (NormalizedNodeContainer<?>) node);
} else {
navigateNormalizedNode(level, newParentPath, node);
}
}
private void navigateNormalizedNodeContainerMixin(final int level, final String parentPath,
- final NormalizedNodeContainer<?, ?, ?> node) {
+ final NormalizedNodeContainer<?> node) {
visitor.visitNode(level, parentPath, node);
String newParentPath = parentPath + "/" + node.getIdentifier().toString();
- for (NormalizedNode<?, ?> normalizedNode : node.getValue()) {
+ for (NormalizedNode normalizedNode : node.body()) {
if (normalizedNode instanceof MixinNode && normalizedNode instanceof NormalizedNodeContainer) {
navigateNormalizedNodeContainerMixin(level + 1, newParentPath,
- (NormalizedNodeContainer<?, ?, ?>) normalizedNode);
+ (NormalizedNodeContainer<?>) normalizedNode);
} else {
navigateNormalizedNode(level, newParentPath, normalizedNode);
}
}
- private void navigateNormalizedNode(final int level, final String parentPath,
- final NormalizedNode<?, ?> normalizedNode) {
+ private void navigateNormalizedNode(final int level, final String parentPath, final NormalizedNode normalizedNode) {
if (normalizedNode instanceof DataContainerNode) {
-
- final DataContainerNode<?> dataContainerNode = (DataContainerNode<?>) normalizedNode;
-
- navigateDataContainerNode(level + 1, parentPath, dataContainerNode);
+ navigateDataContainerNode(level + 1, parentPath, (DataContainerNode) normalizedNode);
} else {
visitor.visitNode(level + 1, parentPath, normalizedNode);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.cluster.datastore.node.utils;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public interface NormalizedNodeVisitor {
- void visitNode(int level, String parentPath, NormalizedNode<?, ?> normalizedNode);
+ void visitNode(int level, String parentPath, NormalizedNode normalizedNode);
}
@FunctionalInterface
public interface Applier<T> {
- void apply(T instance, YangInstanceIdentifier path, NormalizedNode<?, ?> node);
+ void apply(T instance, YangInstanceIdentifier path, NormalizedNode node);
}
- public static Optional<NormalizedNode<?, ?>> readNormalizedNode(final DataInput in) throws IOException {
+ public static Optional<NormalizedNode> readNormalizedNode(final DataInput in) throws IOException {
if (!in.readBoolean()) {
return Optional.empty();
}
return Optional.of(NormalizedNodeDataInput.newDataInput(in).readNormalizedNode());
}
- public static void writeNormalizedNode(final DataOutput out, final @Nullable NormalizedNode<?, ?> node)
+ public static void writeNormalizedNode(final DataOutput out, final @Nullable NormalizedNode node)
throws IOException {
writeNormalizedNode(out, MAGNESIUM, node);
}
- public static void writeNormalizedNode(final DataOutput out,
- final org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeStreamVersion version,
- final @Nullable NormalizedNode<?, ?> node) throws IOException {
+ public static void writeNormalizedNode(final DataOutput out, final NormalizedNodeStreamVersion version,
+ final @Nullable NormalizedNode node) throws IOException {
if (node != null) {
out.writeBoolean(true);
public static <T> void readNodeAndPath(final DataInput in, final T instance, final Applier<T> applier)
throws IOException {
final NormalizedNodeDataInput stream = NormalizedNodeDataInput.newDataInput(in);
- NormalizedNode<?, ?> node = stream.readNormalizedNode();
+ NormalizedNode node = stream.readNormalizedNode();
YangInstanceIdentifier path = stream.readYangInstanceIdentifier();
applier.apply(instance, path, node);
}
public static void writeNodeAndPath(final DataOutput out, final NormalizedNodeStreamVersion version,
- final YangInstanceIdentifier path, final NormalizedNode<?, ?> node) throws IOException {
+ final YangInstanceIdentifier path, final NormalizedNode node) throws IOException {
try (NormalizedNodeDataOutput stream = version.newDataOutput(out)) {
stream.writeNormalizedNode(node);
stream.writeYangInstanceIdentifier(path);
}
public static void writeNodeAndPath(final DataOutput out, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> node) throws IOException {
+ final NormalizedNode node) throws IOException {
writeNodeAndPath(out, MAGNESIUM, path, node);
}
throws IOException {
final NormalizedNodeDataInput stream = NormalizedNodeDataInput.newDataInput(in);
YangInstanceIdentifier path = stream.readYangInstanceIdentifier();
- NormalizedNode<?, ?> node = stream.readNormalizedNode();
+ NormalizedNode node = stream.readNormalizedNode();
applier.apply(instance, path, node);
}
public static void writePathAndNode(final DataOutput out,
final org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeStreamVersion version,
- final YangInstanceIdentifier path, final NormalizedNode<?, ?> node) throws IOException {
+ final YangInstanceIdentifier path, final NormalizedNode node) throws IOException {
try (NormalizedNodeDataOutput stream = version.newDataOutput(out)) {
stream.writeYangInstanceIdentifier(path);
stream.writeNormalizedNode(node);
}
public static void writePathAndNode(final DataOutput out, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> node) throws IOException {
+ final NormalizedNode node) throws IOException {
writePathAndNode(out, MAGNESIUM, path, node);
}
}
private final DataSchemaContextTree tree;
private DataSchemaContextNode<?> nodePathSchemaNode;
- private NormalizedNode<?, ?> normalizedNode;
+ private NormalizedNode normalizedNode;
private State state = State.UNITIALIZED;
private int unknown;
enter(ReusableImmutableNormalizedNodeStreamWriter::startContainerNode, name, childSizeHint);
}
- @Override
- public final void startYangModeledAnyXmlNode(final NodeIdentifier nodeIdentifier, final int count) {
- // FIXME: implement this
- throw new UnsupportedOperationException("Not implemented yet");
- }
-
@Override
public final void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException {
enter(ReusableImmutableNormalizedNodeStreamWriter::startUnkeyedList, name, childSizeHint);
* @return Resulting node for the path, if it was not pruned
* @throws IllegalStateException if this pruner has not been closed
*/
- public final Optional<NormalizedNode<?, ?>> getResult() {
+ public final Optional<NormalizedNode> getResult() {
checkState(state == State.CLOSED, "Cannot get result in state %s", state);
return Optional.ofNullable(normalizedNode);
}
}
@Override
- public final Optional<NormalizedNode<?, ?>> readNode(final PathArgument child) {
+ public final Optional<NormalizedNode> readNode(final PathArgument child) {
throw new UnsupportedOperationException("Not implemented");
}
import java.util.Arrays;
import java.util.Deque;
import java.util.Iterator;
-import org.opendaylight.yangtools.concepts.Variant;
+import org.opendaylight.yangtools.concepts.Either;
/**
* An {@link OutputStream} implementation which collects data is a series of {@code byte[]} chunks, each of which has
return size;
}
- public Variant<byte[], ChunkedByteArray> toVariant() {
+ public Either<byte[], ChunkedByteArray> toVariant() {
checkClosed();
- return result instanceof byte[] ? Variant.ofFirst((byte[]) result)
- : Variant.ofSecond(new ChunkedByteArray(size, (ImmutableList<byte[]>) result));
+ return result instanceof byte[] ? Either.ofFirst((byte[]) result)
+ : Either.ofSecond(new ChunkedByteArray(size, (ImmutableList<byte[]>) result));
}
@VisibleForTesting
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.cluster.schema.provider.impl;
import akka.dispatch.OnComplete;
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.OrderedMapNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.w3c.dom.Document;
@Test
public void testSerializeDeserializeNodes() throws IOException {
- final NormalizedNode<?, ?> normalizedNode = createNormalizedNode();
+ final NormalizedNode normalizedNode = createNormalizedNode();
final byte[] bytes = serializeNormalizedNode(normalizedNode);
assertEquals(10564, bytes.length);
assertEquals(normalizedNode, deserializeNormalizedNode(bytes));
new ByteArrayInputStream("<xml><data/></xml>".getBytes(Charset.defaultCharset()));
final Document parse = UntrustedXML.newDocumentBuilder().parse(is);
final DOMSourceAnyxmlNode anyXmlNode = Builders.anyXmlBuilder()
- .withNodeIdentifier(id("anyXmlNode"))
+ .withNodeIdentifier(id("anyXmlNode"))
.withValue(new DOMSource(parse))
.build();
final byte[] bytes = serializeNormalizedNode(anyXmlNode);
assertEquals(113, bytes.length);
- final NormalizedNode<?, ?> deserialized = deserializeNormalizedNode(bytes);
- final DOMSource value = (DOMSource) deserialized.getValue();
- final Diff diff = XMLUnit.compareXML((Document) anyXmlNode.getValue().getNode(),
+ final NormalizedNode deserialized = deserializeNormalizedNode(bytes);
+ final DOMSource value = (DOMSource) deserialized.body();
+ final Diff diff = XMLUnit.compareXML((Document) anyXmlNode.body().getNode(),
value.getNode().getOwnerDocument());
assertTrue(diff.toString(), diff.similar());
}
public void testSerializeDeserializePathAndNode() throws IOException {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final DataOutput out = new DataOutputStream(bos);
- final NormalizedNode<?, ?> node = createNormalizedNode();
+ final NormalizedNode node = createNormalizedNode();
final YangInstanceIdentifier path = YangInstanceIdentifier.create(id("container1"));
SerializationUtils.writeNodeAndPath(out, path, node);
assertEquals(expected, read);
}
- private static NormalizedNode<?, ?> deserializeNormalizedNode(final byte[] bytes) throws IOException {
+ private static NormalizedNode deserializeNormalizedNode(final byte[] bytes) throws IOException {
return SerializationUtils.readNormalizedNode(new DataInputStream(new ByteArrayInputStream(bytes))).get();
}
- private static byte[] serializeNormalizedNode(final NormalizedNode<?, ?> node) throws IOException {
+ private static byte[] serializeNormalizedNode(final NormalizedNode node) throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
SerializationUtils.writeNormalizedNode(new DataOutputStream(bos), node);
return bos.toByteArray();
}
- private static NormalizedNode<?, ?> createNormalizedNode() {
+ private static NormalizedNode createNormalizedNode() {
final LeafSetNode<Object> leafSetNode = Builders.leafSetBuilder()
.withNodeIdentifier(id("leafSetNode"))
.withChild(createLeafSetEntry("leafSetNode", "leafSetValue1"))
.withChild(entry1)
.withChild(entry2)
.build();
- final OrderedMapNode orderedMapNode = Builders.orderedMapBuilder()
+ final UserMapNode orderedMapNode = Builders.orderedMapBuilder()
.withNodeIdentifier(id("orderedMapNode"))
.withChild(entry2)
.withChild(entry1)
NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner);
- NormalizedNode<?, ?> expected = createTestContainer();
+ NormalizedNode expected = createTestContainer();
normalizedNodeWriter.write(expected);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals(expected, actual);
NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner);
- NormalizedNode<?, ?> expected = createTestContainer();
+ NormalizedNode expected = createTestContainer();
normalizedNodeWriter.write(expected);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals(expected, actual);
NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner);
- NormalizedNode<?, ?> expected = createTestContainer();
+ NormalizedNode expected = createTestContainer();
normalizedNodeWriter.write(expected);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertNotEquals(expected, actual);
NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(pruner);
- NormalizedNode<?, ?> expected = createTestContainer();
+ NormalizedNode expected = createTestContainer();
normalizedNodeWriter.write(expected);
}
- private static int countNodes(final NormalizedNode<?,?> normalizedNode, final String namespaceFilter) {
+ private static int countNodes(final NormalizedNode normalizedNode, final String namespaceFilter) {
if (normalizedNode == null) {
return 0;
}
@Test
public void testLeafNodeNotPrunedWhenHasNoParent() throws IOException {
AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.DESC_QNAME));
- NormalizedNode<?, ?> input = Builders.leafBuilder().withNodeIdentifier(
+ NormalizedNode input = Builders.leafBuilder().withNodeIdentifier(
new NodeIdentifier(TestModel.DESC_QNAME)).withValue("test").build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
.node(TestModel.AUGMENTED_LIST_QNAME).node(augId).build());
LeafNode<Object> child = Builders.leafBuilder().withNodeIdentifier(
new NodeIdentifier(TestModel.INVALID_QNAME)).withValue("test").build();
- NormalizedNode<?, ?> input = Builders.augmentationBuilder().withNodeIdentifier(augId).withChild(child).build();
+ NormalizedNode input = Builders.augmentationBuilder().withNodeIdentifier(augId).withChild(child).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals("normalizedNode", Builders.augmentationBuilder().withNodeIdentifier(augId).build(), actual);
}
@Test
public void testLeafNodePrunedWhenHasNoParentAndSchemaMissing() throws IOException {
AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME));
- NormalizedNode<?, ?> input = Builders.leafBuilder().withNodeIdentifier(
+ NormalizedNode input = Builders.leafBuilder().withNodeIdentifier(
new NodeIdentifier(TestModel.INVALID_QNAME)).withValue("test").build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
@Test
public void testLeafSetEntryNodeNotPrunedWhenHasNoParent() throws IOException {
AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.SHOE_QNAME));
- NormalizedNode<?, ?> input = Builders.leafSetEntryBuilder().withValue("puma").withNodeIdentifier(
+ NormalizedNode input = Builders.leafSetEntryBuilder().withValue("puma").withNodeIdentifier(
new NodeWithValue<>(TestModel.SHOE_QNAME, "puma")).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals("normalizedNode", input, actual);
}
AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.SHOE_QNAME));
LeafSetEntryNode<Object> child = Builders.leafSetEntryBuilder().withValue("puma").withNodeIdentifier(
new NodeWithValue<>(TestModel.SHOE_QNAME, "puma")).build();
- NormalizedNode<?, ?> input = Builders.leafSetBuilder().withNodeIdentifier(
+ NormalizedNode input = Builders.leafSetBuilder().withNodeIdentifier(
new NodeIdentifier(TestModel.SHOE_QNAME)).withChild(child).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals("normalizedNode", input, actual);
}
@Test
public void testLeafSetEntryNodePrunedWhenHasNoParentAndSchemaMissing() throws IOException {
AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME));
- NormalizedNode<?, ?> input = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier(
+ NormalizedNode input = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier(
new NodeWithValue<>(TestModel.INVALID_QNAME, "test")).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.INVALID_QNAME));
LeafSetEntryNode<Object> child = Builders.leafSetEntryBuilder().withValue("test").withNodeIdentifier(
new NodeWithValue<>(TestModel.INVALID_QNAME, "test")).build();
- NormalizedNode<?, ?> input = Builders.leafSetBuilder().withNodeIdentifier(
+ NormalizedNode input = Builders.leafSetBuilder().withNodeIdentifier(
new NodeIdentifier(TestModel.INVALID_QNAME)).withChild(child).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
@Test
public void testAnyXMLNodeNotPrunedWhenHasNoParent() throws IOException {
AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH.node(TestModel.ANY_XML_QNAME));
- NormalizedNode<?, ?> input = Builders.anyXmlBuilder().withNodeIdentifier(
+ NormalizedNode input = Builders.anyXmlBuilder().withNodeIdentifier(
new NodeIdentifier(TestModel.ANY_XML_QNAME)).withValue(mock(DOMSource.class)).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals("normalizedNode", input, actual);
}
AbstractNormalizedNodePruner pruner = prunerFullSchema(TestModel.TEST_PATH);
DOMSourceAnyxmlNode child = Builders.anyXmlBuilder().withNodeIdentifier(
new NodeIdentifier(TestModel.ANY_XML_QNAME)).withValue(mock(DOMSource.class)).build();
- NormalizedNode<?, ?> input = Builders.containerBuilder().withNodeIdentifier(
+ NormalizedNode input = Builders.containerBuilder().withNodeIdentifier(
new NodeIdentifier(TestModel.TEST_QNAME)).withChild(child).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals("normalizedNode", input, actual);
}
@Test
public void testAnyXmlNodePrunedWhenHasNoParentAndSchemaMissing() throws IOException {
AbstractNormalizedNodePruner pruner = prunerNoTestSchema(TestModel.TEST_PATH.node(TestModel.ANY_XML_QNAME));
- NormalizedNode<?, ?> input = Builders.anyXmlBuilder().withNodeIdentifier(
+ NormalizedNode input = Builders.anyXmlBuilder().withNodeIdentifier(
new NodeIdentifier(TestModel.ANY_XML_QNAME)).withValue(mock(DOMSource.class)).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
.node(TestModel.INNER_CONTAINER_QNAME).build();
AbstractNormalizedNodePruner pruner = prunerFullSchema(path);
- NormalizedNode<?, ?> input = ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME);
+ NormalizedNode input = ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME);
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals("normalizedNode", input, actual);
}
.node(TestModel.INVALID_QNAME).build();
AbstractNormalizedNodePruner pruner = prunerFullSchema(path);
- NormalizedNode<?, ?> input = ImmutableNodes.containerNode(TestModel.INVALID_QNAME);
+ NormalizedNode input = ImmutableNodes.containerNode(TestModel.INVALID_QNAME);
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
assertEquals(Optional.empty(), pruner.getResult());
MapNode innerList = mapNodeBuilder(TestModel.INNER_LIST_QNAME).withChild(mapEntryBuilder(
TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one").withChild(
ImmutableNodes.containerNode(TestModel.INVALID_QNAME)).build()).build();
- NormalizedNode<?, ?> input = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1)
+ NormalizedNode input = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1)
.withChild(innerList).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
- NormalizedNode<?, ?> expected = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1)
+ NormalizedNode expected = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1)
.withChild(mapNodeBuilder(TestModel.INNER_LIST_QNAME).withChild(mapEntryBuilder(
TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "one").build()).build()).build();
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals("normalizedNode", expected, actual);
}
ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME)).build()).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals("normalizedNode", input, actual);
}
MapNode innerList = mapNodeBuilder(TestModel.INVALID_QNAME).withChild(mapEntryBuilder(
TestModel.INVALID_QNAME, TestModel.NAME_QNAME, "one").withChild(
ImmutableNodes.containerNode(TestModel.INNER_CONTAINER_QNAME)).build()).build();
- NormalizedNode<?, ?> input = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1)
+ NormalizedNode input = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1)
.withChild(innerList).build();
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
- NormalizedNode<?, ?> expected = mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1);
- NormalizedNode<?, ?> actual = pruner.getResult().orElseThrow();
+ NormalizedNode expected = mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1);
+ NormalizedNode actual = pruner.getResult().orElseThrow();
assertEquals("normalizedNode", expected, actual);
}
- private static NormalizedNode<?, ?> createTestContainer() {
+ private static NormalizedNode createTestContainer() {
byte[] bytes1 = {1, 2, 3};
LeafSetEntryNode<Object> entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).withValue(bytes1).build();
.build()));
}
- private static NormalizedNode<?, ?> prune(final NormalizedNode<?, ?> node) throws IOException {
+ private static NormalizedNode prune(final NormalizedNode node) throws IOException {
final ReusableNormalizedNodePruner pruner = ReusableNormalizedNodePruner.forSchemaContext(CONTEXT)
.withUintAdaption();
pruner.initializeForPath(YangInstanceIdentifier.create(node.getIdentifier()));
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
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.SystemMapNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
familyContainerBuilder = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new NodeIdentifier(FAMILY_QNAME));
- final CollectionNodeBuilder<MapEntryNode, MapNode> childrenBuilder =
- mapNodeBuilder(CHILDREN_QNAME);
+ final CollectionNodeBuilder<MapEntryNode, SystemMapNode> childrenBuilder = mapNodeBuilder()
+ .withNodeIdentifier(new NodeIdentifier(CHILDREN_QNAME));
final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode>
firstChildBuilder = mapEntryBuilder(CHILDREN_QNAME, CHILD_NUMBER_QNAME, FIRST_CHILD_ID);
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
}
@Override
- public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) {
checkRunning(commitImpl);
checkInstanceIdentifierReferencesData(path,data);
getSubtransaction(store).write(path, data);
}
private static void checkInstanceIdentifierReferencesData(final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ final NormalizedNode data) {
checkArgument(data != null, "Attempted to store null data at %s", path);
final PathArgument lastArg = path.getLastPathArgument();
if (lastArg != null) {
}
@Override
- public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) {
checkRunning(commitImpl);
checkInstanceIdentifierReferencesData(path, data);
getSubtransaction(store).merge(path, data);
}
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode>> read(final YangInstanceIdentifier path) {
return delegate().read(path);
}
}
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode>> read(final YangInstanceIdentifier path) {
return delegate().read(path);
}
}
@Override
- public final void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public final void write(final YangInstanceIdentifier path, final NormalizedNode data) {
delegate().write(path, data);
}
@Override
- public final void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public final void merge(final YangInstanceIdentifier path, final NormalizedNode data) {
delegate().merge(path, data);
}
*
* @param identifier Identifier of transaction.
*/
- protected DOMBrokerReadOnlyTransaction(Object identifier,
- Map<LogicalDatastoreType, ? extends DOMStoreTransactionFactory> storeTxFactories) {
+ protected DOMBrokerReadOnlyTransaction(final Object identifier,
+ final Map<LogicalDatastoreType, ? extends DOMStoreTransactionFactory> storeTxFactories) {
super(identifier, storeTxFactories);
}
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+ public FluentFuture<Optional<NormalizedNode>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
return getSubtransaction(store).read(path);
}
}
@Override
- protected DOMStoreReadTransaction createTransaction(LogicalDatastoreType key) {
+ protected DOMStoreReadTransaction createTransaction(final LogicalDatastoreType key) {
return getTxFactory(key).newReadOnlyTransaction();
}
}
* @param identifier identifier of transaction.
* @param storeTxFactories the backing transaction store factories
*/
- protected DOMBrokerReadWriteTransaction(Object identifier,
- Map<LogicalDatastoreType, ? extends DOMStoreTransactionFactory> storeTxFactories,
+ protected DOMBrokerReadWriteTransaction(final Object identifier,
+ final Map<LogicalDatastoreType, ? extends DOMStoreTransactionFactory> storeTxFactories,
final AbstractDOMTransactionFactory<?> commitImpl) {
super(identifier, storeTxFactories, commitImpl);
}
@Override
- public FluentFuture<Optional<NormalizedNode<?,?>>> read(final LogicalDatastoreType store,
+ public FluentFuture<Optional<NormalizedNode>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
return getSubtransaction(store).read(path);
}
}
@Override
- protected DOMStoreReadWriteTransaction createTransaction(LogicalDatastoreType key) {
+ protected DOMStoreReadWriteTransaction createTransaction(final LogicalDatastoreType key) {
return getTxFactory(key).newReadWriteTransaction();
}
}
doDelete(path);
}
- final void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ final void merge(final YangInstanceIdentifier path, final NormalizedNode data) {
checkReadWrite();
checkNotSealed();
doMerge(path, data);
}
- final void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ final void write(final YangInstanceIdentifier path, final NormalizedNode data) {
checkReadWrite();
checkNotSealed();
doWrite(path, data);
return doExists(path);
}
- final FluentFuture<Optional<NormalizedNode<?, ?>>> read(final YangInstanceIdentifier path) {
+ final FluentFuture<Optional<NormalizedNode>> read(final YangInstanceIdentifier path) {
checkNotSealed();
return doRead(path);
}
abstract void doDelete(YangInstanceIdentifier path);
- abstract void doMerge(YangInstanceIdentifier path, NormalizedNode<?, ?> data);
+ abstract void doMerge(YangInstanceIdentifier path, NormalizedNode data);
- abstract void doWrite(YangInstanceIdentifier path, NormalizedNode<?, ?> data);
+ abstract void doWrite(YangInstanceIdentifier path, NormalizedNode data);
abstract FluentFuture<Boolean> doExists(YangInstanceIdentifier path);
- abstract FluentFuture<Optional<NormalizedNode<?, ?>>> doRead(YangInstanceIdentifier path);
+ abstract FluentFuture<Optional<NormalizedNode>> doRead(YangInstanceIdentifier path);
@GuardedBy("this")
abstract Optional<ModifyTransactionRequest> flushState();
return ensureSnapshotProxy(path).exists(path);
}
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode>> read(final YangInstanceIdentifier path) {
return ensureSnapshotProxy(path).read(path);
}
return ensureTransactionProxy(path).exists(path);
}
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode>> read(final YangInstanceIdentifier path) {
return ensureTransactionProxy(path).read(path);
}
ensureTransactionProxy(path).delete(path);
}
- public void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final YangInstanceIdentifier path, final NormalizedNode data) {
ensureTransactionProxy(path).merge(path, data);
}
- public void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void write(final YangInstanceIdentifier path, final NormalizedNode data) {
ensureTransactionProxy(path).write(path, data);
}
}
@Override
- final FluentFuture<Optional<NormalizedNode<?, ?>>> doRead(final YangInstanceIdentifier path) {
+ final FluentFuture<Optional<NormalizedNode>> doRead(final YangInstanceIdentifier path) {
return FluentFutures.immediateFluentFuture(readOnlyView().readNode(path));
}
// listeners, which we do not want to execute while we are reconnecting.
if (request instanceof ReadTransactionRequest) {
final YangInstanceIdentifier path = ((ReadTransactionRequest) request).getPath();
- final Optional<NormalizedNode<?, ?>> result = readOnlyView().readNode(path);
+ final Optional<NormalizedNode> result = readOnlyView().readNode(path);
if (callback != null) {
// XXX: FB does not see that callback is final, on stack and has be check for non-null.
final Consumer<Response<?, ?>> fbIsStupid = requireNonNull(callback);
LOG.debug("Applying modification {} to successor {}", mod, successor);
mod.applyToCursor(new AbstractDataTreeModificationCursor() {
@Override
- public void write(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public void write(final PathArgument child, final NormalizedNode data) {
successor.write(current().node(child), data);
}
@Override
- public void merge(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public void merge(final PathArgument child, final NormalizedNode data) {
successor.merge(current().node(child), data);
}
* @author Robert Varga
*/
final class LocalReadOnlyProxyTransaction extends LocalProxyTransaction {
-
private final DataTreeSnapshot snapshot;
LocalReadOnlyProxyTransaction(final ProxyHistory parent, final TransactionIdentifier identifier,
}
@Override
- void doMerge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ void doMerge(final YangInstanceIdentifier path, final NormalizedNode data) {
throw new UnsupportedOperationException("doMerge");
}
@Override
- void doWrite(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ void doWrite(final YangInstanceIdentifier path, final NormalizedNode data) {
throw new UnsupportedOperationException("doWrite");
}
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- void doMerge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ void doMerge(final YangInstanceIdentifier path, final NormalizedNode data) {
final CursorAwareDataTreeModification mod = getModification();
if (recordedFailure != null) {
LOG.debug("Transaction {} recorded failure, ignoring merge to {}", getIdentifier(), path);
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- void doWrite(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ void doWrite(final YangInstanceIdentifier path, final NormalizedNode data) {
final CursorAwareDataTreeModification mod = getModification();
if (recordedFailure != null) {
LOG.debug("Transaction {} recorded failure, ignoring write to {}", getIdentifier(), path);
sealedModification.applyToCursor(new AbstractDataTreeModificationCursor() {
@Override
- public void write(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public void write(final PathArgument child, final NormalizedNode data) {
b.addModification(new TransactionWrite(current().node(child), data));
}
@Override
- public void merge(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public void merge(final PathArgument child, final NormalizedNode data) {
b.addModification(new TransactionMerge(current().node(child), data));
}
}
@Override
- void doMerge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ void doMerge(final YangInstanceIdentifier path, final NormalizedNode data) {
appendModification(new TransactionMerge(path, data), OptionalLong.empty());
}
@Override
- void doWrite(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ void doWrite(final YangInstanceIdentifier path, final NormalizedNode data) {
appendModification(new TransactionWrite(path, data), OptionalLong.empty());
}
}
@Override
- FluentFuture<Optional<NormalizedNode<?, ?>>> doRead(final YangInstanceIdentifier path) {
- final SettableFuture<Optional<NormalizedNode<?, ?>>> future = SettableFuture.create();
+ FluentFuture<Optional<NormalizedNode>> doRead(final YangInstanceIdentifier path) {
+ final SettableFuture<Optional<NormalizedNode>> future = SettableFuture.create();
return sendReadRequest(new ReadTransactionRequest(getIdentifier(), nextSequence(), localActor(), path,
isSnapshotOnly()), t -> completeRead(path, future, t), future);
}
recordFinishedRequest(response);
}
- private void completeRead(final YangInstanceIdentifier path,
- final SettableFuture<Optional<NormalizedNode<?, ?>>> future, final Response<?, ?> response) {
+ private void completeRead(final YangInstanceIdentifier path, final SettableFuture<Optional<NormalizedNode>> future,
+ final Response<?, ?> response) {
LOG.debug("Read request for {} completed with {}", path, response);
if (response instanceof ReadTransactionSuccess) {
mod.applyToCursor(new AbstractDataTreeModificationCursor() {
@Override
- public void write(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public void write(final PathArgument child, final NormalizedNode data) {
appendModification(new TransactionWrite(current().node(child), data), optTicks);
}
@Override
- public void merge(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public void merge(final PathArgument child, final NormalizedNode data) {
appendModification(new TransactionMerge(current().node(child), data), optTicks);
}
}
private ExistsTransactionSuccess handleExistsTransaction(final ExistsTransactionRequest request) {
- final Optional<NormalizedNode<?, ?>> data = openTransaction.getSnapshot().readNode(request.getPath());
+ final Optional<NormalizedNode> data = openTransaction.getSnapshot().readNode(request.getPath());
return recordSuccess(request.getSequence(), new ExistsTransactionSuccess(openTransaction.getIdentifier(),
request.getSequence(), data.isPresent()));
}
private ReadTransactionSuccess handleReadTransaction(final ReadTransactionRequest request) {
- final Optional<NormalizedNode<?, ?>> data = openTransaction.getSnapshot().readNode(request.getPath());
+ final Optional<NormalizedNode> data = openTransaction.getSnapshot().readNode(request.getPath());
return recordSuccess(request.getSequence(), new ReadTransactionSuccess(openTransaction.getIdentifier(),
request.getSequence(), data));
}
}
private ExistsTransactionSuccess handleExistsTransaction(final ExistsTransactionRequest request) {
- final Optional<NormalizedNode<?, ?>> data = checkOpen().getSnapshot().readNode(request.getPath());
+ final Optional<NormalizedNode> data = checkOpen().getSnapshot().readNode(request.getPath());
return recordSuccess(request.getSequence(), new ExistsTransactionSuccess(getIdentifier(), request.getSequence(),
data.isPresent()));
}
private ReadTransactionSuccess handleReadTransaction(final ReadTransactionRequest request) {
- final Optional<NormalizedNode<?, ?>> data = checkOpen().getSnapshot().readNode(request.getPath());
+ final Optional<NormalizedNode> data = checkOpen().getSnapshot().readNode(request.getPath());
return recordSuccess(request.getSequence(), new ReadTransactionSuccess(getIdentifier(), request.getSequence(),
data));
}
protected abstract DOMStoreReadTransaction getReadDelegate();
@SuppressWarnings("checkstyle:IllegalCatch")
- private void executeModification(Consumer<DOMStoreWriteTransaction> consumer) {
+ private void executeModification(final Consumer<DOMStoreWriteTransaction> consumer) {
incrementModificationCount();
if (operationError == null) {
try {
}
@Override
- public void executeMerge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data,
- final Boolean havePermit) {
+ public void executeMerge(final YangInstanceIdentifier path, final NormalizedNode data, final Boolean havePermit) {
executeModification(transaction -> transaction.merge(path, data));
}
@Override
- public void executeWrite(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data,
- final Boolean havePermit) {
+ public void executeWrite(final YangInstanceIdentifier path, final NormalizedNode data, final Boolean havePermit) {
executeModification(transaction -> transaction.write(path, data));
}
}
@Override
- public void executeMerge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data,
- final Boolean havePermit) {
+ public void executeMerge(final YangInstanceIdentifier path, final NormalizedNode data, final Boolean havePermit) {
LOG.debug("Tx {} executeMerge called path = {}", getIdentifier(), path);
}
@Override
- public void executeWrite(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data,
- final Boolean havePermit) {
+ public void executeWrite(final YangInstanceIdentifier path, final NormalizedNode data, final Boolean havePermit) {
LOG.debug("Tx {} executeWrite called path = {}", getIdentifier(), path);
}
}
}
@Override
- public void executeMerge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data,
- final Boolean havePermit) {
+ public void executeMerge(final YangInstanceIdentifier path, final NormalizedNode data, final Boolean havePermit) {
LOG.debug("Tx {} executeMerge called path = {}", getIdentifier(), path);
executeModification(new MergeModification(path, data), havePermit);
}
@Override
- public void executeWrite(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data,
- final Boolean havePermit) {
+ public void executeWrite(final YangInstanceIdentifier path, final NormalizedNode data, final Boolean havePermit) {
LOG.debug("Tx {} executeWrite called path = {}", getIdentifier(), path);
executeModification(new WriteModification(path, data), havePermit);
}
if (havePermit == null) {
permitToRelease = failedModification == null && acquireOperation();
} else {
- permitToRelease = havePermit.booleanValue();
+ permitToRelease = havePermit;
}
batchModification(modification, permitToRelease);
// Send any batched modifications. This is necessary to honor the read uncommitted semantics of the
// public API contract.
- final boolean permitToRelease = havePermit == null ? acquireOperation() : havePermit.booleanValue();
+ final boolean permitToRelease = havePermit == null ? acquireOperation() : havePermit;
sendBatchedModifications();
OnComplete<Object> onComplete = new OnComplete<>() {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNodes;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final class RootDataTreeChangeListenerActor extends DataTreeChangeListenerActor {
initial = Iterables.get(changes, 0);
}
- final NormalizedNode<?, ?> root = initial.getRootNode().getDataAfter().orElseThrow();
+ final NormalizedNode root = initial.getRootNode().getDataAfter().orElseThrow();
verify(root instanceof ContainerNode, "Unexpected root node %s", root);
- ((ContainerNode) root).getValue().forEach(rootBuilder::withChild);
+ ((ContainerNode) root).body().forEach(rootBuilder::withChild);
}
}
// We will not be intercepting any other messages, allow initial state to be reclaimed as soon as possible
* @return A state snapshot
*/
@NonNull ShardDataTreeSnapshot takeStateSnapshot() {
- final NormalizedNode<?, ?> rootNode = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.empty()).get();
+ final NormalizedNode rootNode = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.empty()).get();
final Builder<Class<? extends ShardDataTreeSnapshotMetadata<?>>, ShardDataTreeSnapshotMetadata<?>> metaBuilder =
ImmutableMap.builder();
// delete everything first
mod.delete(YangInstanceIdentifier.empty());
- final Optional<NormalizedNode<?, ?>> maybeNode = snapshot.getRootNode();
+ final Optional<NormalizedNode> maybeNode = snapshot.getRootNode();
if (maybeNode.isPresent()) {
// Add everything from the remote node back
mod.write(YangInstanceIdentifier.empty(), maybeNode.get());
id, shard.getDatastoreContext().getInitialPayloadSerializedBufferCapacity()), callback);
}
- public Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier path) {
+ public Optional<NormalizedNode> readNode(final YangInstanceIdentifier path) {
return dataTree.takeSnapshot().readNode(path);
}
open = false;
}
- private File writeRoot(final String kind, final NormalizedNode<?, ?> node) {
+ private File writeRoot(final String kind, final NormalizedNode node) {
final File file = new File(System.getProperty("karaf.data", "."),
"failed-recovery-" + kind + "-" + shardName + ".xml");
NormalizedNodeXMLOutput.toFile(file, node);
void executeDelete(YangInstanceIdentifier path, Boolean havePermit);
- void executeMerge(YangInstanceIdentifier path, NormalizedNode<?, ?> data, Boolean havePermit);
+ void executeMerge(YangInstanceIdentifier path, NormalizedNode data, Boolean havePermit);
- void executeWrite(YangInstanceIdentifier path, NormalizedNode<?, ?> data, Boolean havePermit);
+ void executeWrite(YangInstanceIdentifier path, NormalizedNode data, Boolean havePermit);
Future<Object> directCommit(Boolean havePermit);
*/
abstract class TransactionModificationOperation extends TransactionOperation {
private abstract static class AbstractDataOperation extends TransactionModificationOperation {
- private final NormalizedNode<?, ?> data;
+ private final NormalizedNode data;
- AbstractDataOperation(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ AbstractDataOperation(final YangInstanceIdentifier path, final NormalizedNode data) {
super(path);
this.data = requireNonNull(data);
}
- final NormalizedNode<?, ?> data() {
+ final NormalizedNode data() {
return data;
}
}
}
static final class MergeOperation extends AbstractDataOperation {
- MergeOperation(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ MergeOperation(final YangInstanceIdentifier path, final NormalizedNode data) {
super(path, data);
}
}
static final class WriteOperation extends AbstractDataOperation {
- WriteOperation(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ WriteOperation(final YangInstanceIdentifier path, final NormalizedNode data) {
super(path, data);
}
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.concurrent.Future;
}
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode>> read(final YangInstanceIdentifier path) {
checkState(type != TransactionType.WRITE_ONLY, "Reads from write-only transactions are not allowed");
requireNonNull(path, "path should not be null");
return path.isEmpty() ? readAllData() : singleShardRead(shardNameFromIdentifier(path), path);
}
- private FluentFuture<Optional<NormalizedNode<?, ?>>> singleShardRead(
- final String shardName, final YangInstanceIdentifier path) {
+ private FluentFuture<Optional<NormalizedNode>> singleShardRead(final String shardName,
+ final YangInstanceIdentifier path) {
return executeRead(shardName, new ReadData(path, DataStoreVersions.CURRENT_VERSION));
}
- private FluentFuture<Optional<NormalizedNode<?, ?>>> readAllData() {
+ private FluentFuture<Optional<NormalizedNode>> readAllData() {
final Set<String> allShardNames = txContextFactory.getActorUtils().getConfiguration().getAllShardNames();
- final Collection<FluentFuture<Optional<NormalizedNode<?, ?>>>> futures = new ArrayList<>(allShardNames.size());
+ final Collection<FluentFuture<Optional<NormalizedNode>>> futures = new ArrayList<>(allShardNames.size());
for (String shardName : allShardNames) {
futures.add(singleShardRead(shardName, YangInstanceIdentifier.empty()));
}
- final ListenableFuture<List<Optional<NormalizedNode<?, ?>>>> listFuture = Futures.allAsList(futures);
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> aggregateFuture;
+ final ListenableFuture<List<Optional<NormalizedNode>>> listFuture = Futures.allAsList(futures);
+ final ListenableFuture<Optional<NormalizedNode>> aggregateFuture;
aggregateFuture = Futures.transform(listFuture, input -> {
try {
}
@Override
- public void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final YangInstanceIdentifier path, final NormalizedNode data) {
checkModificationState("merge", path);
if (path.isEmpty()) {
private void mergeAllData(final ContainerNode rootData) {
// Populate requests for individual shards that are being touched
final Map<String, DataContainerNodeBuilder<NodeIdentifier, ContainerNode>> rootBuilders = new HashMap<>();
- for (DataContainerChild<?, ?> child : rootData.getValue()) {
+ for (DataContainerChild child : rootData.body()) {
final String shardName = shardNameFromRootChild(child);
rootBuilders.computeIfAbsent(shardName,
unused -> Builders.containerBuilder().withNodeIdentifier(rootData.getIdentifier()))
}
@Override
- public void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void write(final YangInstanceIdentifier path, final NormalizedNode data) {
checkModificationState("write", path);
if (path.isEmpty()) {
}
// Now distribute children as needed
- for (DataContainerChild<?, ?> child : rootData.getValue()) {
+ for (DataContainerChild child : rootData.body()) {
final String shardName = shardNameFromRootChild(child);
verifyNotNull(rootBuilders.get(shardName), "Failed to find builder for %s", shardName).addChild(child);
}
getContextWrapper(operation.path()).maybeExecuteTransactionOperation(operation);
}
- private static ContainerNode checkRootData(final NormalizedNode<?, ?> data) {
+ private static ContainerNode checkRootData(final NormalizedNode data) {
// Root has to be a container
checkArgument(data instanceof ContainerNode, "Invalid root data %s", data);
return (ContainerNode) data;
return new ThreePhaseCommitCohortProxy(txContextFactory.getActorUtils(), cohorts, getIdentifier());
}
- private String shardNameFromRootChild(final DataContainerChild<?, ?> child) {
+ private String shardNameFromRootChild(final DataContainerChild child) {
return shardNameFromIdentifier(YangInstanceIdentifier.create(child.getIdentifier()));
}
requireNonNull(config, "ModuleShardConfiguration should not be null");
ModuleConfig moduleConfig = ModuleConfig.builder(config.getModuleName())
- .nameSpace(config.getNamespace().toASCIIString())
+ .nameSpace(config.getNamespace().toString())
.shardStrategy(createShardStrategy(config.getModuleName(), config.getShardStrategyName()))
.shardConfig(config.getShardName(), config.getShardMemberNames()).build();
import static java.util.Objects.requireNonNull;
-import java.net.URI;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
/**
* Encapsulates information for adding a new module shard configuration.
* @author Thomas Pantelis
*/
public class ModuleShardConfiguration {
- private final URI namespace;
+ private final XMLNamespace namespace;
private final String moduleName;
private final String shardName;
private final String shardStrategyName;
* is used.
* @param shardMemberNames the names of the shard's member replicas.
*/
- public ModuleShardConfiguration(@NonNull URI namespace, @NonNull String moduleName, @NonNull String shardName,
- @Nullable String shardStrategyName, @NonNull Collection<MemberName> shardMemberNames) {
+ public ModuleShardConfiguration(final @NonNull XMLNamespace namespace, final @NonNull String moduleName,
+ final @NonNull String shardName, final @Nullable String shardStrategyName,
+ final @NonNull Collection<MemberName> shardMemberNames) {
this.namespace = requireNonNull(namespace, "nameSpace should not be null");
this.moduleName = requireNonNull(moduleName, "moduleName should not be null");
this.shardName = requireNonNull(shardName, "shardName should not be null");
this.shardMemberNames = requireNonNull(shardMemberNames, "shardMemberNames");
}
- public URI getNamespace() {
+ public XMLNamespace getNamespace() {
return namespace;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.cluster.datastore.messages;
import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public class ReadData extends AbstractRead<Optional<NormalizedNode<?, ?>>> {
+public class ReadData extends AbstractRead<Optional<NormalizedNode>> {
private static final long serialVersionUID = 1L;
public ReadData() {
}
- public ReadData(final YangInstanceIdentifier path, short version) {
+ public ReadData(final YangInstanceIdentifier path, final short version) {
super(path, version);
}
@Override
- public FluentFuture<Optional<NormalizedNode<?, ?>>> apply(DOMStoreReadTransaction readDelegate) {
+ public FluentFuture<Optional<NormalizedNode>> apply(final DOMStoreReadTransaction readDelegate) {
return readDelegate.read(getPath());
}
@Override
- public void processResponse(Object readResponse, SettableFuture<Optional<NormalizedNode<?, ?>>> returnFuture) {
+ public void processResponse(final Object readResponse,
+ final SettableFuture<Optional<NormalizedNode>> returnFuture) {
if (ReadDataReply.isSerializedType(readResponse)) {
ReadDataReply reply = ReadDataReply.fromSerializable(readResponse);
- returnFuture.set(Optional.<NormalizedNode<?, ?>>ofNullable(reply.getNormalizedNode()));
+ returnFuture.set(Optional.ofNullable(reply.getNormalizedNode()));
} else {
returnFuture.setException(new ReadFailedException("Invalid response reading data for path " + getPath()));
}
}
@Override
- protected AbstractRead<Optional<NormalizedNode<?, ?>>> newInstance(short withVersion) {
+ protected AbstractRead<Optional<NormalizedNode>> newInstance(final short withVersion) {
return new ReadData(getPath(), withVersion);
}
return (ReadData)serializable;
}
- public static boolean isSerializedType(Object message) {
+ public static boolean isSerializedType(final Object message) {
return message instanceof ReadData;
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.cluster.datastore.messages;
import java.io.IOException;
public class ReadDataReply extends VersionedExternalizableMessage {
private static final long serialVersionUID = 1L;
- private NormalizedNode<?, ?> normalizedNode;
+ private NormalizedNode normalizedNode;
public ReadDataReply() {
}
- public ReadDataReply(final NormalizedNode<?, ?> normalizedNode, final short version) {
+ public ReadDataReply(final NormalizedNode normalizedNode, final short version) {
super(version);
this.normalizedNode = normalizedNode;
}
- public NormalizedNode<?, ?> getNormalizedNode() {
+ public NormalizedNode getNormalizedNode() {
return normalizedNode;
}
package org.opendaylight.controller.cluster.datastore.messages;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.util.AbstractEffectiveModelContextProvider;
+import org.opendaylight.yangtools.yang.model.spi.AbstractEffectiveModelContextProvider;
public class UpdateSchemaContext extends AbstractEffectiveModelContextProvider {
public UpdateSchemaContext(final EffectiveModelContext modelContext) {
super(version);
}
- public MergeModification(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public MergeModification(final YangInstanceIdentifier path, final NormalizedNode data) {
super(path, data);
}
- MergeModification(final short version, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ MergeModification(final short version, final YangInstanceIdentifier path, final NormalizedNode data) {
super(version, path, data);
}
public static MergeModification fromStream(final NormalizedNodeDataInput in, final short version,
final ReusableStreamReceiver receiver) throws IOException {
- final NormalizedNode<?, ?> node = in.readNormalizedNode(receiver);
+ final NormalizedNode node = in.readNormalizedNode(receiver);
final YangInstanceIdentifier path = in.readYangInstanceIdentifier();
return new MergeModification(version, path, node);
}
public class WriteModification extends AbstractModification {
private static final long serialVersionUID = 1L;
- private NormalizedNode<?, ?> data;
+ private NormalizedNode data;
public WriteModification() {
this(DataStoreVersions.CURRENT_VERSION);
super(version);
}
- WriteModification(final short version, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ WriteModification(final short version, final YangInstanceIdentifier path, final NormalizedNode data) {
super(version, path);
this.data = data;
}
- public WriteModification(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public WriteModification(final YangInstanceIdentifier path, final NormalizedNode data) {
super(path);
this.data = data;
}
transaction.write(getPath(), data);
}
- public NormalizedNode<?, ?> getData() {
+ public NormalizedNode getData() {
return data;
}
public static WriteModification fromStream(final NormalizedNodeDataInput in, final short version,
final ReusableStreamReceiver receiver) throws IOException {
- final NormalizedNode<?, ?> node = in.readNormalizedNode(receiver);
+ final NormalizedNode node = in.readNormalizedNode(receiver);
final YangInstanceIdentifier path = in.readYangInstanceIdentifier();
return new WriteModification(version, path, node);
}
}
@Override
- public final Optional<NormalizedNode<?, ?>> getDataBefore() {
+ public final Optional<NormalizedNode> getDataBefore() {
throw new UnsupportedOperationException("Before-image not available after serialization");
}
}
@Override
- public Optional<NormalizedNode<?, ?>> getDataAfter() {
+ public Optional<NormalizedNode> getDataAfter() {
throw new UnsupportedOperationException("After-image not available after serialization");
}
*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import com.google.common.base.Verify;
+import static com.google.common.base.Verify.verifyNotNull;
+
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
}
@Override
- public final Optional<NormalizedNode<?, ?>> getRootNode() {
- return Optional.of(Verify.verifyNotNull(rootNode(), "Snapshot %s returned non-present root node", getClass()));
+ public final Optional<NormalizedNode> getRootNode() {
+ return Optional.of(verifyNotNull(rootNode(), "Snapshot %s returned non-present root node", getClass()));
}
/**
*
* @return The root node.
*/
- abstract @NonNull NormalizedNode<?, ?> rootNode();
+ abstract @NonNull NormalizedNode rootNode();
/**
* Return the snapshot payload version. Implementations of this method should return a constant.
import org.opendaylight.controller.cluster.io.ChunkedByteArray;
import org.opendaylight.controller.cluster.io.ChunkedOutputStream;
import org.opendaylight.controller.cluster.raft.protobuff.client.messages.IdentifiablePayload;
-import org.opendaylight.yangtools.concepts.Variant;
+import org.opendaylight.yangtools.concepts.Either;
import org.opendaylight.yangtools.yang.data.api.schema.stream.ReusableStreamReceiver;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.impl.schema.ReusableImmutableNormalizedNodeStreamWriter;
DataTreeCandidateInputOutput.writeDataTreeCandidate(dos, version, candidate);
}
- final Variant<byte[], ChunkedByteArray> source = cos.toVariant();
+ final Either<byte[], ChunkedByteArray> source = cos.toVariant();
LOG.debug("Initial buffer capacity {}, actual serialized size {}", initialSerializedBufferCapacity, cos.size());
return source.isFirst() ? new Simple(source.getFirst()) : new Chunked(source.getSecond());
}
}
@Override
- public final Optional<NormalizedNode<?, ?>> getDataAfter() {
+ public final Optional<NormalizedNode> getDataAfter() {
return Optional.empty();
}
private Map<Class<? extends ShardDataTreeSnapshotMetadata<?>>, ShardDataTreeSnapshotMetadata<?>> metadata;
private NormalizedNodeStreamVersion version;
- private NormalizedNode<?, ?> rootNode;
+ private NormalizedNode rootNode;
// checkstyle flags the public modifier as redundant which really doesn't make sense since it clearly isn't
// redundant. It is explicitly needed for Java serialization to be able to create instances via reflection.
private final Map<Class<? extends ShardDataTreeSnapshotMetadata<?>>, ShardDataTreeSnapshotMetadata<?>> metadata;
@SuppressFBWarnings(value = "SE_BAD_FIELD", justification = "See above justification.")
- private final NormalizedNode<?, ?> rootNode;
+ private final NormalizedNode rootNode;
- public MetadataShardDataTreeSnapshot(final NormalizedNode<?, ?> rootNode) {
+ public MetadataShardDataTreeSnapshot(final NormalizedNode rootNode) {
this(rootNode, ImmutableMap.of());
}
- public MetadataShardDataTreeSnapshot(final NormalizedNode<?, ?> rootNode,
+ public MetadataShardDataTreeSnapshot(final NormalizedNode rootNode,
final Map<Class<? extends ShardDataTreeSnapshotMetadata<?>>, ShardDataTreeSnapshotMetadata<?>> metadata) {
this.rootNode = requireNonNull(rootNode);
this.metadata = ImmutableMap.copyOf(metadata);
}
@Override
- NormalizedNode<?, ?> rootNode() {
+ NormalizedNode rootNode() {
return rootNode;
}
}
@Override
- public final Optional<NormalizedNode<?, ?>> getDataAfter() {
+ public final Optional<NormalizedNode> getDataAfter() {
throw new UnsupportedOperationException("After-image not available after serialization");
}
*
* @return An optional root node.
*/
- public abstract Optional<NormalizedNode<?, ?>> getRootNode();
+ public abstract Optional<NormalizedNode> getRootNode();
public abstract void serialize(ObjectOutput out) throws IOException;
}
return UNKNOWN_MODULE_NAME;
}
- String namespace = path.getPathArguments().get(0).getNodeType().getNamespace().toASCIIString();
+ String namespace = path.getPathArguments().get(0).getNodeType().getNamespace().toString();
String moduleName = configuration.getModuleNameFromNameSpace(namespace);
return moduleName != null ? moduleName : UNKNOWN_MODULE_NAME;
}
* @author Thomas Pantelis
*/
public abstract class AbstractBatchedModificationsCursor extends AbstractDataTreeModificationCursor {
-
protected abstract BatchedModifications getModifications();
@Override
}
@Override
- public final void merge(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public final void merge(final PathArgument child, final NormalizedNode data) {
getModifications().addModification(new MergeModification(current().node(child), data));
}
@Override
- public final void write(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public final void write(final PathArgument child, final NormalizedNode data) {
getModifications().addModification(new WriteModification(current().node(child), data));
}
}
}
@Override
- public void merge(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public void merge(final PathArgument child, final NormalizedNode data) {
outputPathAndNode("MERGE", child, data);
}
@Override
- public void write(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public void write(final PathArgument child, final NormalizedNode data) {
outputPathAndNode("WRITE", child, data);
}
- private void outputPathAndNode(final String name, final PathArgument child, final NormalizedNode<?, ?> data) {
+ private void outputPathAndNode(final String name, final PathArgument child, final NormalizedNode data) {
try {
output.writeByte('\n');
output.write(name.getBytes(StandardCharsets.UTF_8));
public final class NormalizedNodeAggregator {
private final YangInstanceIdentifier rootIdentifier;
- private final List<Optional<NormalizedNode<?, ?>>> nodes;
+ private final List<Optional<NormalizedNode>> nodes;
private final DataTree dataTree;
private NormalizedNodeAggregator(final YangInstanceIdentifier rootIdentifier,
- final List<Optional<NormalizedNode<?, ?>>> nodes, final EffectiveModelContext schemaContext,
+ final List<Optional<NormalizedNode>> nodes, final EffectiveModelContext schemaContext,
final LogicalDatastoreType logicalDatastoreType) {
this.rootIdentifier = rootIdentifier;
this.nodes = nodes;
/**
* Combine data from all the nodes in the list into a tree with root as rootIdentifier.
*/
- public static Optional<NormalizedNode<?,?>> aggregate(final YangInstanceIdentifier rootIdentifier,
- final List<Optional<NormalizedNode<?, ?>>> nodes, final EffectiveModelContext schemaContext,
+ public static Optional<NormalizedNode> aggregate(final YangInstanceIdentifier rootIdentifier,
+ final List<Optional<NormalizedNode>> nodes, final EffectiveModelContext schemaContext,
final LogicalDatastoreType logicalDatastoreType) throws DataValidationFailedException {
return new NormalizedNodeAggregator(rootIdentifier, nodes, schemaContext, logicalDatastoreType).aggregate();
}
- private Optional<NormalizedNode<?,?>> aggregate() throws DataValidationFailedException {
+ private Optional<NormalizedNode> aggregate() throws DataValidationFailedException {
return combine().getRootNode();
}
private NormalizedNodeAggregator combine() throws DataValidationFailedException {
final DataTreeModification mod = dataTree.takeSnapshot().newModification();
- for (final Optional<NormalizedNode<?,?>> node : nodes) {
+ for (final Optional<NormalizedNode> node : nodes) {
if (node.isPresent()) {
mod.merge(rootIdentifier, node.get());
}
return this;
}
- private Optional<NormalizedNode<?, ?>> getRootNode() {
+ private Optional<NormalizedNode> getRootNode() {
return dataTree.takeSnapshot().readNode(rootIdentifier);
}
}
private NormalizedNodeXMLOutput() {
}
- public static void toStream(OutputStream outStream, NormalizedNode<?, ?> node)
+ public static void toStream(final OutputStream outStream, final NormalizedNode node)
throws XMLStreamException, IOException {
XMLStreamWriter xmlWriter = XOF.createXMLStreamWriter(outStream);
}
}
- public static void toFile(File file, NormalizedNode<?, ?> node) {
+ public static void toFile(final File file, final NormalizedNode node) {
try (FileOutputStream outStream = new FileOutputStream(file)) {
toStream(outStream, node);
} catch (IOException | XMLStreamException e) {
}
@Override
- public void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final YangInstanceIdentifier path, final NormalizedNode data) {
pruneAndMergeNode(path, data);
}
@Override
- public void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void write(final YangInstanceIdentifier path, final NormalizedNode data) {
pruneAndWriteNode(path, data);
}
}
@Override
- public void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final YangInstanceIdentifier path, final NormalizedNode data) {
if (path.isEmpty()) {
pruneAndMergeNode(path, data);
return;
}
@Override
- public void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void write(final YangInstanceIdentifier path, final NormalizedNode data) {
if (path.isEmpty()) {
pruneAndWriteNode(path, data);
return;
}
}
- final void pruneAndMergeNode(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
- final NormalizedNode<?, ?> pruned = pruneNormalizedNode(path, data);
+ final void pruneAndMergeNode(final YangInstanceIdentifier path, final NormalizedNode data) {
+ final NormalizedNode pruned = pruneNormalizedNode(path, data);
if (pruned != null) {
delegate.merge(path, pruned);
}
}
- final void pruneAndWriteNode(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
- final NormalizedNode<?, ?> pruned = pruneNormalizedNode(path, data);
+ final void pruneAndWriteNode(final YangInstanceIdentifier path, final NormalizedNode data) {
+ final NormalizedNode pruned = pruneNormalizedNode(path, data);
if (pruned != null) {
delegate.write(path, pruned);
}
}
@Override
- public final Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier yangInstanceIdentifier) {
+ public final Optional<NormalizedNode> readNode(final YangInstanceIdentifier yangInstanceIdentifier) {
return delegate.readNode(yangInstanceIdentifier);
}
}
@VisibleForTesting
- final NormalizedNode<?, ?> pruneNormalizedNode(final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> input) {
+ final NormalizedNode pruneNormalizedNode(final YangInstanceIdentifier path, final NormalizedNode input) {
pruner.initializeForPath(path);
try {
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
}
@Override
- public void write(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public void write(final PathArgument child, final NormalizedNode data) {
final YangInstanceIdentifier path = current().node(child);
- final NormalizedNode<?, ?> prunedNode = pruningModification.pruneNormalizedNode(path, data);
+ final NormalizedNode prunedNode = pruningModification.pruneNormalizedNode(path, data);
if (prunedNode != null) {
toModification.write(path, prunedNode);
}
}
@Override
- public void merge(final PathArgument child, final NormalizedNode<?, ?> data) {
+ public void merge(final PathArgument child, final NormalizedNode data) {
final YangInstanceIdentifier path = current().node(child);
- final NormalizedNode<?, ?> prunedNode = pruningModification.pruneNormalizedNode(path, data);
+ final NormalizedNode prunedNode = pruningModification.pruneNormalizedNode(path, data);
if (prunedNode != null) {
toModification.merge(path, prunedNode);
}
private ClientBackedReadTransaction object;
@Mock
- private NormalizedNode<?, ?> data;
+ private NormalizedNode data;
@Mock
private ClientActorContext clientContext;
@Mock
@Test
public void testRead() throws Exception {
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> result = object().read(YangInstanceIdentifier.empty());
- final Optional<NormalizedNode<?, ?>> resultData = result.get();
+ final ListenableFuture<Optional<NormalizedNode>> result = object().read(YangInstanceIdentifier.empty());
+ final Optional<NormalizedNode> resultData = result.get();
assertTrue(resultData.isPresent());
assertEquals(data, resultData.get());
}
@Mock
private ClientTransaction delegate;
@Mock
- private NormalizedNode<?, ?> data;
+ private NormalizedNode data;
@Mock
private DOMStoreThreePhaseCommitCohort readyCohort;
@Test
public void testRead() throws Exception {
- final FluentFuture<Optional<NormalizedNode<?, ?>>> result = object().read(YangInstanceIdentifier.empty());
- final Optional<NormalizedNode<?, ?>> resultData = result.get();
+ final FluentFuture<Optional<NormalizedNode>> result = object().read(YangInstanceIdentifier.empty());
+ final Optional<NormalizedNode> resultData = result.get();
assertTrue(resultData.isPresent());
assertEquals(data, resultData.get());
}
@Mock
private ClientTransaction delegate;
@Mock
- private NormalizedNode<?, ?> data;
+ private NormalizedNode data;
@Mock
private YangInstanceIdentifier path;
@Mock
@Test
public void testRead() throws Exception {
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> exists = getHandle().read(PATH);
+ final ListenableFuture<Optional<NormalizedNode>> exists = getHandle().read(PATH);
verify(getDataTreeSnapshot()).readNode(PATH);
assertFalse(getWithTimeout(exists).isPresent());
}
-
}
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.CursorAwareDataTreeModification;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
private static final YangInstanceIdentifier PATH = YangInstanceIdentifier.builder()
.node(QName.create("ns-1", "node-1"))
.build();
- private static final NormalizedNode<?, ?> DATA = Builders.containerBuilder()
+ private static final ContainerNode DATA = Builders.containerBuilder()
.withNodeIdentifier(YangInstanceIdentifier.NodeIdentifier.create(PATH.getLastPathArgument().getNodeType()))
.build();
@Test
public void testRead() throws Exception {
- final FluentFuture<Optional<NormalizedNode<?, ?>>> resultFuture = getHandle().read(PATH);
+ final FluentFuture<Optional<NormalizedNode>> resultFuture = getHandle().read(PATH);
verify(modification).readNode(PATH);
- final Optional<NormalizedNode<?, ?>> result = getWithTimeout(resultFuture);
+ final Optional<NormalizedNode> result = getWithTimeout(resultFuture);
assertTrue(result.isPresent());
assertEquals(DATA, result.get());
}
@Test
public void testRead() throws Exception {
final TransactionTester<RemoteProxyTransaction> tester = getTester();
- final FluentFuture<Optional<NormalizedNode<?, ?>>> read = transaction.read(PATH_2);
+ final FluentFuture<Optional<NormalizedNode>> read = transaction.read(PATH_2);
final ReadTransactionRequest req = tester.expectTransactionRequest(ReadTransactionRequest.class);
- final Optional<NormalizedNode<?, ?>> result = Optional.of(DATA_1);
+ final Optional<NormalizedNode> result = Optional.of(DATA_1);
tester.replySuccess(new ReadTransactionSuccess(TRANSACTION_ID, req.getSequence(), result));
assertFutureEquals(result, read);
}
// Verify the data in the store
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
- Optional<NormalizedNode<?, ?>> optional = readTx.read(carPath).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> optional = readTx.read(carPath).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", car, optional.get());
// 2. Write some data
final YangInstanceIdentifier nodePath = TestModel.TEST_PATH;
- final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
readWriteTx.write(nodePath, nodeToWrite);
// 3. Read the data from Tx
final Boolean exists = readWriteTx.exists(nodePath).get(5, TimeUnit.SECONDS);
assertEquals("exists", Boolean.TRUE, exists);
- Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(nodePath).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> optional = readWriteTx.read(nodePath).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", nodeToWrite, optional.get());
final Boolean exists = readWriteTx.exists(carPath).get(5, TimeUnit.SECONDS);
assertEquals("exists", Boolean.TRUE, exists);
- Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", car, optional.get());
assertTrue(frontendMetadata.getClients().get(0).getCurrentHistories().isEmpty());
}
- final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
+ final Optional<NormalizedNode> optional = txChain.newReadOnlyTransaction()
.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
- assertEquals("# cars", numCars, ((Collection<?>) optional.get().getValue()).size());
+ assertEquals("# cars", numCars, ((Collection<?>) optional.get().body()).size());
}
}
assertNotNull("newWriteOnlyTransaction returned null", writeTx);
// 2. Write some data
- final NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
writeTx.write(TestModel.TEST_PATH, testNode);
// 3. Ready the Tx for commit
// the data from the first
// Tx is visible after being readied.
DOMStoreReadTransaction readTx = txChain.newReadOnlyTransaction();
- Optional<NormalizedNode<?, ?>> optional = readTx.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> optional = readTx.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", testNode, optional.get());
final YangInstanceIdentifier personPath = PeopleModel.newPersonPath("jack");
readWriteTx.merge(personPath, person);
- Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", car, optional.get());
f.get(5, TimeUnit.SECONDS);
}
- final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
+ final Optional<NormalizedNode> optional = txChain.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
- assertEquals("# cars", numCars, ((Collection<?>) optional.get().getValue()).size());
+ assertEquals("# cars", numCars, ((Collection<?>) optional.get().body()).size());
txChain.close();
final DOMStoreReadWriteTransaction rwTx2 = txChain.newReadWriteTransaction();
- final Optional<NormalizedNode<?, ?>> optional = rwTx2.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
+ final Optional<NormalizedNode> optional = rwTx2.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
assertFalse("isPresent", optional.isPresent());
txChain.close();
final DOMStoreThreePhaseCommitCohort cohort1 = writeTx.ready();
// Create read-only tx's and issue a read.
- FluentFuture<Optional<NormalizedNode<?, ?>>> readFuture1 = txChain
+ FluentFuture<Optional<NormalizedNode>> readFuture1 = txChain
.newReadOnlyTransaction().read(TestModel.TEST_PATH);
- FluentFuture<Optional<NormalizedNode<?, ?>>> readFuture2 = txChain
+ FluentFuture<Optional<NormalizedNode>> readFuture2 = txChain
.newReadOnlyTransaction().read(TestModel.TEST_PATH);
// Create another write tx and issue the write.
DataTree dataTree = new InMemoryDataTreeFactory().create(
DataTreeConfiguration.DEFAULT_OPERATIONAL, SchemaContextHelper.full());
AbstractShardTest.writeToStore(dataTree, CarsModel.BASE_PATH, carsNode);
- NormalizedNode<?, ?> root = AbstractShardTest.readStore(dataTree, YangInstanceIdentifier.empty());
+ NormalizedNode root = AbstractShardTest.readStore(dataTree, YangInstanceIdentifier.empty());
final Snapshot carsSnapshot = Snapshot.create(
new ShardSnapshotState(new MetadataShardDataTreeSnapshot(root)),
dataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_OPERATIONAL,
SchemaContextHelper.full());
- final NormalizedNode<?, ?> peopleNode = PeopleModel.create();
+ final NormalizedNode peopleNode = PeopleModel.create();
AbstractShardTest.writeToStore(dataTree, PeopleModel.BASE_PATH, peopleNode);
root = AbstractShardTest.readStore(dataTree, YangInstanceIdentifier.empty());
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
// two reads
- Optional<NormalizedNode<?, ?>> optional = readTx.read(CarsModel.BASE_PATH).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> optional = readTx.read(CarsModel.BASE_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", carsNode, optional.get());
ContainerNode rootNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(YangInstanceIdentifier.NodeIdentifier.create(SchemaContext.NAME))
- .withChild((ContainerNode) CarsModel.create())
+ .withChild(CarsModel.create())
.build();
testKit.testWriteTransaction(dataStore, YangInstanceIdentifier.empty(), rootNode);
import org.opendaylight.controller.md.cluster.datastore.model.CarsModel;
import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
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.NormalizedNode;
// Verify data in the data store.
- final NormalizedNode<?, ?> outerList = readStore(shard, TestModel.OUTER_LIST_PATH);
+ final NormalizedNode outerList = readStore(shard, TestModel.OUTER_LIST_PATH);
assertNotNull(TestModel.OUTER_LIST_QNAME.getLocalName() + " not found", outerList);
assertTrue(TestModel.OUTER_LIST_QNAME.getLocalName() + " value is not Iterable",
- outerList.getValue() instanceof Iterable);
- for (final Object entry: (Iterable<?>) outerList.getValue()) {
+ outerList.body() instanceof Iterable);
+ for (final Object entry: (Iterable<?>) outerList.body()) {
assertTrue(TestModel.OUTER_LIST_QNAME.getLocalName() + " entry is not MapEntryNode",
entry instanceof MapEntryNode);
final MapEntryNode mapEntry = (MapEntryNode)entry;
- final Optional<DataContainerChild<? extends PathArgument, ?>> idLeaf =
- mapEntry.getChild(new YangInstanceIdentifier.NodeIdentifier(TestModel.ID_QNAME));
+ final Optional<DataContainerChild> idLeaf =
+ mapEntry.findChildByArg(new YangInstanceIdentifier.NodeIdentifier(TestModel.ID_QNAME));
assertTrue("Missing leaf " + TestModel.ID_QNAME.getLocalName(), idLeaf.isPresent());
- final Object value = idLeaf.get().getValue();
+ final Object value = idLeaf.get().body();
assertTrue("Unexpected value for leaf " + TestModel.ID_QNAME.getLocalName() + ": " + value,
listEntryKeys.remove(value));
}
}
protected static BatchedModifications prepareBatchedModifications(final TransactionIdentifier transactionID,
- final YangInstanceIdentifier path, final NormalizedNode<?, ?> data, final boolean doCommitOnReady) {
+ final YangInstanceIdentifier path, final NormalizedNode data, final boolean doCommitOnReady) {
final MutableCompositeModification modification = new MutableCompositeModification();
modification.addModification(new WriteModification(path, data));
return prepareBatchedModifications(transactionID, modification, doCommitOnReady);
protected static ForwardedReadyTransaction prepareForwardedReadyTransaction(final TestActorRef<Shard> shard,
final TransactionIdentifier transactionID, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> data, final boolean doCommitOnReady) {
+ final NormalizedNode data, final boolean doCommitOnReady) {
ReadWriteShardDataTreeTransaction rwTx = shard.underlyingActor().getDataStore()
.newReadWriteTransaction(transactionID);
rwTx.getSnapshot().write(path, data);
return new ForwardedReadyTransaction(transactionID, CURRENT_VERSION, rwTx, doCommitOnReady, Optional.empty());
}
- public static NormalizedNode<?,?> readStore(final TestActorRef<? extends Shard> shard,
+ public static NormalizedNode readStore(final TestActorRef<? extends Shard> shard,
final YangInstanceIdentifier id) {
return shard.underlyingActor().getDataStore().readNode(id).orElse(null);
}
- public static NormalizedNode<?,?> readStore(final DataTree store, final YangInstanceIdentifier id) {
+ public static NormalizedNode readStore(final DataTree store, final YangInstanceIdentifier id) {
return store.takeSnapshot().readNode(id).orElse(null);
}
public void writeToStore(final TestActorRef<Shard> shard, final YangInstanceIdentifier id,
- final NormalizedNode<?,?> node) throws InterruptedException, ExecutionException {
+ final NormalizedNode node) throws InterruptedException, ExecutionException {
Future<Object> future = Patterns.ask(shard, newBatchedModifications(nextTransactionId(),
id, node, true, true, 1), new Timeout(5, TimeUnit.SECONDS));
try {
}
public static void writeToStore(final ShardDataTree store, final YangInstanceIdentifier id,
- final NormalizedNode<?,?> node) throws DataValidationFailedException {
+ final NormalizedNode node) throws DataValidationFailedException {
BatchedModifications batched = newBatchedModifications(nextTransactionId(), id, node, true, true, 1);
DataTreeModification modification = store.getDataTree().takeSnapshot().newModification();
batched.apply(modification);
store.notifyListeners(commitTransaction(store.getDataTree(), modification));
}
- public static void writeToStore(final DataTree store, final YangInstanceIdentifier id,
- final NormalizedNode<?,?> node) throws DataValidationFailedException {
+ public static void writeToStore(final DataTree store, final YangInstanceIdentifier id, final NormalizedNode node)
+ throws DataValidationFailedException {
final DataTreeModification transaction = store.takeSnapshot().newModification();
transaction.write(id, node);
store.commit(candidate);
}
- public void mergeToStore(final ShardDataTree store, final YangInstanceIdentifier id,
- final NormalizedNode<?,?> node) throws DataValidationFailedException {
+ public void mergeToStore(final ShardDataTree store, final YangInstanceIdentifier id, final NormalizedNode node)
+ throws DataValidationFailedException {
final BatchedModifications batched = new BatchedModifications(nextTransactionId(), CURRENT_VERSION);
batched.addModification(new MergeModification(id, node));
batched.setReady();
writeToStore(testStore, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- final NormalizedNode<?, ?> root = readStore(testStore, YangInstanceIdentifier.empty());
+ final NormalizedNode root = readStore(testStore, YangInstanceIdentifier.empty());
InMemorySnapshotStore.addSnapshot(shardID.toString(), Snapshot.create(
new ShardSnapshotState(new MetadataShardDataTreeSnapshot(root)),
}
static BatchedModifications newBatchedModifications(final TransactionIdentifier transactionID,
- final YangInstanceIdentifier path, final NormalizedNode<?, ?> data, final boolean ready,
+ final YangInstanceIdentifier path, final NormalizedNode data, final boolean ready,
final boolean doCommitOnReady, final int messagesSent) {
final BatchedModifications batched = new BatchedModifications(transactionID, CURRENT_VERSION);
batched.addModification(new WriteModification(path, data));
}
static BatchedModifications newReadyBatchedModifications(final TransactionIdentifier transactionID,
- final YangInstanceIdentifier path, final NormalizedNode<?, ?> data,
+ final YangInstanceIdentifier path, final NormalizedNode data,
final SortedSet<String> participatingShardNames) {
final BatchedModifications batched = new BatchedModifications(transactionID, CURRENT_VERSION);
batched.addModification(new WriteModification(path, data));
@SuppressWarnings("unchecked")
static void verifyOuterListEntry(final TestActorRef<Shard> shard, final Object expIDValue) {
- final NormalizedNode<?, ?> outerList = readStore(shard, TestModel.OUTER_LIST_PATH);
+ final NormalizedNode outerList = readStore(shard, TestModel.OUTER_LIST_PATH);
assertNotNull(TestModel.OUTER_LIST_QNAME.getLocalName() + " not found", outerList);
assertTrue(TestModel.OUTER_LIST_QNAME.getLocalName() + " value is not Iterable",
- outerList.getValue() instanceof Iterable);
- final Object entry = ((Iterable<Object>)outerList.getValue()).iterator().next();
+ outerList.body() instanceof Iterable);
+ final Object entry = ((Iterable<Object>)outerList.body()).iterator().next();
assertTrue(TestModel.OUTER_LIST_QNAME.getLocalName() + " entry is not MapEntryNode",
entry instanceof MapEntryNode);
final MapEntryNode mapEntry = (MapEntryNode)entry;
- final Optional<DataContainerChild<? extends PathArgument, ?>> idLeaf =
- mapEntry.getChild(new YangInstanceIdentifier.NodeIdentifier(TestModel.ID_QNAME));
+ final Optional<DataContainerChild> idLeaf =
+ mapEntry.findChildByArg(new YangInstanceIdentifier.NodeIdentifier(TestModel.ID_QNAME));
assertTrue("Missing leaf " + TestModel.ID_QNAME.getLocalName(), idLeaf.isPresent());
- assertEquals(TestModel.ID_QNAME.getLocalName() + " value", expIDValue, idLeaf.get().getValue());
+ assertEquals(TestModel.ID_QNAME.getLocalName() + " value", expIDValue, idLeaf.get().body());
}
public static DataTreeCandidateTip mockCandidate(final String name) {
@Override
public String getModuleNameFromNameSpace(final String nameSpace) {
- if (TestModel.JUNK_QNAME.getNamespace().toASCIIString().equals(nameSpace)) {
+ if (TestModel.JUNK_QNAME.getNamespace().toString().equals(nameSpace)) {
return TestModel.JUNK_QNAME.getLocalName();
- } else if (CarsModel.BASE_QNAME.getNamespace().toASCIIString().equals(nameSpace)) {
+ } else if (CarsModel.BASE_QNAME.getNamespace().toString().equals(nameSpace)) {
return CarsModel.BASE_QNAME.getLocalName();
}
return null;
final TransactionType type) {
class CreateTransactionArgumentMatcher implements ArgumentMatcher<CreateTransaction> {
@Override
- public boolean matches(CreateTransaction argument) {
+ public boolean matches(final CreateTransaction argument) {
return argument.getTransactionId().getHistoryId().getClientId().getFrontendId().getMemberName()
.getName().equals(expMemberName) && argument.getTransactionType() == type.ordinal();
}
protected DataExists eqDataExists() {
class DataExistsArgumentMatcher implements ArgumentMatcher<DataExists> {
@Override
- public boolean matches(DataExists argument) {
+ public boolean matches(final DataExists argument) {
return argument.getPath().equals(TestModel.TEST_PATH);
}
}
protected ReadData eqReadData(final YangInstanceIdentifier path) {
class ReadDataArgumentMatcher implements ArgumentMatcher<ReadData> {
@Override
- public boolean matches(ReadData argument) {
+ public boolean matches(final ReadData argument) {
return argument.getPath().equals(path);
}
}
}
- protected Future<ReadDataReply> readDataReply(final NormalizedNode<?, ?> data) {
+ protected Future<ReadDataReply> readDataReply(final NormalizedNode data) {
return Futures.successful(new ReadDataReply(data, DataStoreVersions.CURRENT_VERSION));
}
while (iter.hasNext()) {
Object actual = iter.next();
if (CommitTransactionReply.isSerializedType(expReply)
- && CommitTransactionReply.isSerializedType(actual)) {
- found = true;
- } else if (expReply instanceof ActorSelection && Objects.equals(expReply, actual)) {
+ && CommitTransactionReply.isSerializedType(actual)
+ || expReply instanceof ActorSelection && Objects.equals(expReply, actual)) {
found = true;
} else if (expReply instanceof Class && ((Class<?>) expReply).isInstance(actual)) {
found = true;
private static void assertDataTreeCandidate(final DOMDataTreeCandidate candidate,
final DOMDataTreeIdentifier expTreeId, final ModificationType expType,
- final Optional<NormalizedNode<?, ?>> expDataAfter, final Optional<NormalizedNode<?, ?>> expDataBefore) {
+ final Optional<NormalizedNode> expDataAfter, final Optional<NormalizedNode> expDataBefore) {
assertNotNull("Expected candidate for path " + expTreeId.getRootIdentifier(), candidate);
assertEquals("rootPath", expTreeId, candidate.getRootPath());
assertEquals("modificationType", expType, candidate.getRootNode().getModificationType());
return new ShardManagerSnapshot(Arrays.asList(shards), Collections.emptyMap());
}
- private static Snapshot newSnapshot(final YangInstanceIdentifier path, final NormalizedNode<?, ?> node)
- throws Exception {
+ private static Snapshot newSnapshot(final YangInstanceIdentifier path, final NormalizedNode node) throws Exception {
DataTree dataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_OPERATIONAL,
SchemaContextHelper.full());
AbstractShardTest.writeToStore(dataTree, path, node);
- NormalizedNode<?, ?> root = AbstractShardTest.readStore(dataTree, YangInstanceIdentifier.empty());
+ NormalizedNode root = AbstractShardTest.readStore(dataTree, YangInstanceIdentifier.empty());
return Snapshot.create(new ShardSnapshotState(new MetadataShardDataTreeSnapshot(root)),
Collections.<ReplicatedLogEntry>emptyList(), 2, 1, 2, 1, 1, "member-1", null);
// Verify the data in the store
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
- Optional<NormalizedNode<?, ?>> optional = readTx.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> optional = readTx.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
optional = readTx.read(TestModel.OUTER_LIST_PATH).get(5, TimeUnit.SECONDS);
// Do some reads on the Tx on a separate thread.
final AtomicReference<FluentFuture<Boolean>> txExistsFuture = new AtomicReference<>();
- final AtomicReference<FluentFuture<Optional<NormalizedNode<?, ?>>>> txReadFuture = new AtomicReference<>();
+ final AtomicReference<FluentFuture<Optional<NormalizedNode>>> txReadFuture = new AtomicReference<>();
final AtomicReference<Exception> caughtEx = new AtomicReference<>();
final CountDownLatch txReadsDone = new CountDownLatch(1);
final Thread txThread = new Thread(() -> {
assertNotNull("newReadWriteTransaction returned null", readWriteTx);
// Do a read on the Tx on a separate thread.
- final AtomicReference<FluentFuture<Optional<NormalizedNode<?, ?>>>> txReadFuture = new AtomicReference<>();
+ final AtomicReference<FluentFuture<Optional<NormalizedNode>>> txReadFuture = new AtomicReference<>();
final AtomicReference<Exception> caughtEx = new AtomicReference<>();
final CountDownLatch txReadDone = new CountDownLatch(1);
final Thread txThread = new Thread(() -> {
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.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.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
private static void verifyCars(final DOMStoreReadTransaction readTx, final MapEntryNode... entries)
throws Exception {
- final Optional<NormalizedNode<?, ?>> optional = readTx.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
+ final Optional<NormalizedNode> optional = readTx.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
- final CollectionNodeBuilder<MapEntryNode, MapNode> listBuilder = ImmutableNodes.mapNodeBuilder(
+ final CollectionNodeBuilder<MapEntryNode, SystemMapNode> listBuilder = ImmutableNodes.mapNodeBuilder(
CarsModel.CAR_QNAME);
- for (final NormalizedNode<?, ?> entry: entries) {
+ for (final NormalizedNode entry: entries) {
listBuilder.withChild((MapEntryNode) entry);
}
}
private static void verifyNode(final DOMStoreReadTransaction readTx, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> expNode) throws Exception {
- final Optional<NormalizedNode<?, ?>> optional = readTx.read(path).get(5, TimeUnit.SECONDS);
+ final NormalizedNode expNode) throws Exception {
+ final Optional<NormalizedNode> optional = readTx.read(path).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", expNode, optional.get());
}
}
});
- final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
+ final Optional<NormalizedNode> optional = txChain.newReadOnlyTransaction()
.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
- assertEquals("# cars", numCars, ((Collection<?>) optional.get().getValue()).size());
+ assertEquals("# cars", numCars, ((Collection<?>) optional.get().body()).size());
}
@Test
}
});
- final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
+ final Optional<NormalizedNode> optional = txChain.newReadOnlyTransaction()
.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
- assertEquals("# cars", numCars, ((Collection<?>) optional.get().getValue()).size());
+ assertEquals("# cars", numCars, ((Collection<?>) optional.get().body()).size());
}
@Test
assertNotNull("newWriteOnlyTransaction returned null", writeTx);
final YangInstanceIdentifier carsPath = CarsModel.BASE_PATH;
- final NormalizedNode<?, ?> carsNode = CarsModel.emptyContainer();
+ final NormalizedNode carsNode = CarsModel.emptyContainer();
writeTx.write(carsPath, carsNode);
final YangInstanceIdentifier peoplePath = PeopleModel.BASE_PATH;
- final NormalizedNode<?, ?> peopleNode = PeopleModel.emptyContainer();
+ final NormalizedNode peopleNode = PeopleModel.emptyContainer();
writeTx.write(peoplePath, peopleNode);
followerTestKit.doCommit(writeTx.ready());
assertNotNull("newReadWriteTransaction returned null", rwTx);
final YangInstanceIdentifier carsPath = CarsModel.BASE_PATH;
- final NormalizedNode<?, ?> carsNode = CarsModel.emptyContainer();
+ final NormalizedNode carsNode = CarsModel.emptyContainer();
rwTx.write(carsPath, carsNode);
final YangInstanceIdentifier peoplePath = PeopleModel.BASE_PATH;
- final NormalizedNode<?, ?> peopleNode = PeopleModel.emptyContainer();
+ final NormalizedNode peopleNode = PeopleModel.emptyContainer();
rwTx.write(peoplePath, peopleNode);
followerTestKit.doCommit(rwTx.ready());
final YangInstanceIdentifier personPath = PeopleModel.newPersonPath("jack");
readWriteTx.merge(personPath, person);
- Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", car, optional.get());
cars.add(CarsModel.newCarEntry("car" + carIndex, Uint64.valueOf(carIndex)));
writeTx2.write(CarsModel.newCarPath("car" + carIndex), cars.getLast());
carIndex++;
- NormalizedNode<?, ?> people = ImmutableNodes.mapNodeBuilder(PeopleModel.PERSON_QNAME)
+ NormalizedNode people = ImmutableNodes.mapNodeBuilder(PeopleModel.PERSON_QNAME)
.withChild(PeopleModel.newPersonEntry("Dude")).build();
writeTx2.write(PeopleModel.PERSON_LIST_PATH, people);
final DOMStoreThreePhaseCommitCohort writeTx2Cohort = writeTx2.ready();
CarsModel.newCarsMapNode(CarsModel.newCarEntry("optima", Uint64.valueOf(20000))));
AbstractShardTest.writeToStore(tree, CarsModel.BASE_PATH, carsNode);
- final NormalizedNode<?, ?> snapshotRoot = AbstractShardTest.readStore(tree, YangInstanceIdentifier.empty());
+ final NormalizedNode snapshotRoot = AbstractShardTest.readStore(tree, YangInstanceIdentifier.empty());
final Snapshot initialSnapshot = Snapshot.create(
new ShardSnapshotState(new MetadataShardDataTreeSnapshot(snapshotRoot)),
Collections.emptyList(), 5, 1, 5, 1, 1, null, null);
initDatastoresWithCars(testName);
- final Optional<NormalizedNode<?, ?>> readOptional = leaderDistributedDataStore.newReadOnlyTransaction().read(
+ final Optional<NormalizedNode> readOptional = leaderDistributedDataStore.newReadOnlyTransaction().read(
CarsModel.BASE_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", readOptional.isPresent());
assertEquals("Node", carsNode, readOptional.get());
final DOMStoreReadWriteTransaction rwTx = followerDistributedDataStore.newReadWriteTransaction();
- final NormalizedNode<?, ?> carsNode = CarsModel.create();
+ final NormalizedNode carsNode = CarsModel.create();
rwTx.write(CarsModel.BASE_PATH, carsNode);
verifyNode(rwTx, CarsModel.BASE_PATH, carsNode);
leaderTestKit.waitForMembersUp("member-2");
final ContainerNode rootNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(YangInstanceIdentifier.NodeIdentifier.create(SchemaContext.NAME))
- .withChild((ContainerNode) CarsModel.create())
+ .withChild(CarsModel.create())
.build();
leaderTestKit.testWriteTransaction(leaderDistributedDataStore, YangInstanceIdentifier.empty(), rootNode);
}
private static void verifySnapshot(final Snapshot actual, final Snapshot expected,
- final NormalizedNode<?, ?> expRoot) {
+ final NormalizedNode expRoot) {
assertEquals("Snapshot getLastAppliedTerm", expected.getLastAppliedTerm(), actual.getLastAppliedTerm());
assertEquals("Snapshot getLastAppliedIndex", expected.getLastAppliedIndex(), actual.getLastAppliedIndex());
assertEquals("Snapshot getLastTerm", expected.getLastTerm(), actual.getLastTerm());
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.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
@RunWith(Parameterized.class)
public class DistributedDataStoreWithSegmentedJournalIntegrationTest
@Test
public void testManyWritesDeletes() throws Exception {
final IntegrationTestKit testKit = new IntegrationTestKit(getSystem(), datastoreContextBuilder);
- CollectionNodeBuilder<MapEntryNode, MapNode> carMapBuilder = ImmutableNodes.mapNodeBuilder(CAR_QNAME);
+ CollectionNodeBuilder<MapEntryNode, SystemMapNode> carMapBuilder = ImmutableNodes.mapNodeBuilder(CAR_QNAME);
try (AbstractDataStore dataStore = testKit.setupAbstractDataStore(
testParameter, "testManyWritesDeletes", "module-shards-cars-member-1.conf", true, "cars")) {
}
}
- final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
+ final Optional<NormalizedNode> optional = txChain.newReadOnlyTransaction()
.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
DOMStoreTransactionChain txChain = dataStore.createTransactionChain();
MapNode cars = carMapBuilder.build();
- final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
+ final Optional<NormalizedNode> optional = txChain.newReadOnlyTransaction()
.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("restored cars do not match snapshot", cars, optional.get());
}
void testWriteTransaction(final AbstractDataStore dataStore, final YangInstanceIdentifier nodePath,
- final NormalizedNode<?, ?> nodeToWrite) throws Exception {
+ final NormalizedNode nodeToWrite) throws Exception {
// 1. Create a write-only Tx
DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
- Optional<NormalizedNode<?, ?>> optional = readTx.read(nodePath).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> optional = readTx.read(nodePath).get(5, TimeUnit.SECONDS);
assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", nodeToWrite, optional.get());
}
@Test
public void testWrite() {
YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.empty();
- NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
+ NormalizedNode normalizedNode = mock(NormalizedNode.class);
localTransactionContext.executeWrite(yangInstanceIdentifier, normalizedNode, null);
verify(readWriteTransaction).write(yangInstanceIdentifier, normalizedNode);
}
@Test
public void testMerge() {
YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.empty();
- NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
+ NormalizedNode normalizedNode = mock(NormalizedNode.class);
localTransactionContext.executeMerge(yangInstanceIdentifier, normalizedNode, null);
verify(readWriteTransaction).merge(yangInstanceIdentifier, normalizedNode);
}
@Test
public void testRead() {
YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.empty();
- NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
+ NormalizedNode normalizedNode = mock(NormalizedNode.class);
doReturn(FluentFutures.immediateFluentFuture(Optional.of(normalizedNode))).when(readWriteTransaction)
.read(yangInstanceIdentifier);
localTransactionContext.executeRead(new ReadData(yangInstanceIdentifier, DataStoreVersions.CURRENT_VERSION),
@Test
public void testReadyWithWriteError() {
YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.empty();
- NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
+ NormalizedNode normalizedNode = mock(NormalizedNode.class);
RuntimeException error = new RuntimeException("mock");
doThrow(error).when(readWriteTransaction).write(yangInstanceIdentifier, normalizedNode);
@Test
public void testReadyWithMergeError() {
YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.empty();
- NormalizedNode<?, ?> normalizedNode = mock(NormalizedNode.class);
+ NormalizedNode normalizedNode = mock(NormalizedNode.class);
RuntimeException error = new RuntimeException("mock");
doThrow(error).when(readWriteTransaction).merge(yangInstanceIdentifier, normalizedNode);
static void verifyInnerListEntry(TestActorRef<Shard> shard, int outerID, String innerID) {
final YangInstanceIdentifier path = innerEntryPath(outerID, innerID);
- final NormalizedNode<?, ?> innerListEntry = readStore(shard, path);
+ final NormalizedNode innerListEntry = readStore(shard, path);
assertNotNull(path + " not found", innerListEntry);
}
}
final DataTreeSnapshot snapshot1 = readOnlyShardDataTreeTransaction.getSnapshot();
- final Optional<NormalizedNode<?, ?>> optional = snapshot1.readNode(CarsModel.BASE_PATH);
+ final Optional<NormalizedNode> optional = snapshot1.readNode(CarsModel.BASE_PATH);
assertEquals(expectedCarsPresent, optional.isPresent());
- final Optional<NormalizedNode<?, ?>> optional1 = snapshot1.readNode(PeopleModel.BASE_PATH);
+ final Optional<NormalizedNode> optional1 = snapshot1.readNode(PeopleModel.BASE_PATH);
assertEquals(expectedPeoplePresent, optional1.isPresent());
}
candidates.add(addCar(shardDataTree));
candidates.add(removeCar(shardDataTree));
- final NormalizedNode<?, ?> expected = getCars(shardDataTree);
+ final NormalizedNode expected = getCars(shardDataTree);
applyCandidates(shardDataTree, candidates);
- final NormalizedNode<?, ?> actual = getCars(shardDataTree);
+ final NormalizedNode actual = getCars(shardDataTree);
assertEquals(expected, actual);
}
candidates.add(addCar(shardDataTree));
candidates.add(removeCar(shardDataTree));
- final NormalizedNode<?, ?> expected = getCars(shardDataTree);
+ final NormalizedNode expected = getCars(shardDataTree);
applyCandidates(shardDataTree, candidates);
- final NormalizedNode<?, ?> actual = getCars(shardDataTree);
+ final NormalizedNode actual = getCars(shardDataTree);
assertEquals(expected, actual);
}
final ShardDataTreeCohort cohort2 = newShardDataTreeCohort(snapshot ->
snapshot.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode()));
- NormalizedNode<?, ?> peopleNode = PeopleModel.create();
+ NormalizedNode peopleNode = PeopleModel.create();
final ShardDataTreeCohort cohort3 = newShardDataTreeCohort(snapshot ->
snapshot.write(PeopleModel.BASE_PATH, peopleNode));
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
- Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
+ Optional<NormalizedNode> optional = snapshot.readNode(carPath);
assertTrue("Car node present", optional.isPresent());
assertEquals("Car node", carNode, optional.get());
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
- Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
+ Optional<NormalizedNode> optional = snapshot.readNode(carPath);
assertTrue("Car node present", optional.isPresent());
assertEquals("Car node", carNode, optional.get());
}
inOrder.verify(commitCallback3).onSuccess(any(UnsignedLong.class));
final DataTreeSnapshot snapshot = shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
- Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(CarsModel.BASE_PATH);
+ Optional<NormalizedNode> optional = snapshot.readNode(CarsModel.BASE_PATH);
assertTrue("Car node present", optional.isPresent());
}
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
- Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
+ Optional<NormalizedNode> optional = snapshot.readNode(carPath);
assertTrue("Car node present", optional.isPresent());
assertEquals("Car node", carNode, optional.get());
}
final ShardDataTreeCohort cohort2 = newShardDataTreeCohort(snapshot ->
snapshot.write(CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode()));
- NormalizedNode<?, ?> peopleNode = PeopleModel.create();
+ NormalizedNode peopleNode = PeopleModel.create();
final ShardDataTreeCohort cohort3 = newShardDataTreeCohort(snapshot ->
snapshot.write(PeopleModel.BASE_PATH, peopleNode));
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
- Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(PeopleModel.BASE_PATH);
+ Optional<NormalizedNode> optional = snapshot.readNode(PeopleModel.BASE_PATH);
assertTrue("People node present", optional.isPresent());
assertEquals("People node", peopleNode, optional.get());
}
// Verify uint translation
final DataTreeSnapshot snapshot = shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
- final NormalizedNode<?, ?> cars = snapshot.readNode(CarsModel.CAR_LIST_PATH).get();
+ final NormalizedNode cars = snapshot.readNode(CarsModel.CAR_LIST_PATH).get();
assertEquals(Builders.mapBuilder()
.withNodeIdentifier(new NodeIdentifier(CarsModel.CAR_QNAME))
private void assertCarsUint64() {
final DataTreeSnapshot snapshot = shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
- final NormalizedNode<?, ?> cars = snapshot.readNode(CarsModel.CAR_LIST_PATH).get();
+ final NormalizedNode cars = snapshot.readNode(CarsModel.CAR_LIST_PATH).get();
assertEquals(Builders.mapBuilder()
.withNodeIdentifier(new NodeIdentifier(CarsModel.CAR_QNAME))
reset(listener);
}
- private static NormalizedNode<?, ?> getCars(final ShardDataTree shardDataTree) {
+ private static NormalizedNode getCars(final ShardDataTree shardDataTree) {
final ReadOnlyShardDataTreeTransaction readOnlyShardDataTreeTransaction =
shardDataTree.newReadOnlyTransaction(nextTransactionId());
final DataTreeSnapshot snapshot1 = readOnlyShardDataTreeTransaction.getSnapshot();
- final Optional<NormalizedNode<?, ?>> optional = snapshot1.readNode(CarsModel.BASE_PATH);
+ final Optional<NormalizedNode> optional = snapshot1.readNode(CarsModel.BASE_PATH);
assertTrue(optional.isPresent());
return dataTree.prepare(modification);
}
- private Optional<NormalizedNode<?,?>> readCars(final ShardDataTree shardDataTree) {
+ private Optional<NormalizedNode> readCars(final ShardDataTree shardDataTree) {
final DataTree dataTree = shardDataTree.getDataTree();
// FIXME: this should not be called here
dataTree.setEffectiveModelContext(peopleSchemaContext);
return shardDataTree.readNode(CarsModel.BASE_PATH);
}
- private Optional<NormalizedNode<?,?>> readPeople(final ShardDataTree shardDataTree) {
+ private Optional<NormalizedNode> readPeople(final ShardDataTree shardDataTree) {
final DataTree dataTree = shardDataTree.getDataTree();
// FIXME: this should not be called here
dataTree.setEffectiveModelContext(peopleSchemaContext);
writeToStore(store, TestModel.TEST_PATH, container);
final YangInstanceIdentifier root = YangInstanceIdentifier.empty();
- final NormalizedNode<?,?> expected = readStore(store, root);
+ final NormalizedNode expected = readStore(store, root);
final Snapshot snapshot = Snapshot.create(new ShardSnapshotState(new MetadataShardDataTreeSnapshot(expected)),
Collections.emptyList(), 1, 2, 3, 4, -1, null, null);
while (sw.elapsed(TimeUnit.SECONDS) <= 5) {
Uninterruptibles.sleepUninterruptibly(75, TimeUnit.MILLISECONDS);
- final NormalizedNode<?,?> actual = readStore(shard, TestModel.TEST_PATH);
+ final NormalizedNode actual = readStore(shard, TestModel.TEST_PATH);
if (actual != null) {
assertEquals("Applied state", node, actual);
return;
// Verify data in the data store.
- final NormalizedNode<?, ?> actualNode = readStore(shard, path);
+ final NormalizedNode actualNode = readStore(shard, path);
assertEquals("Stored node", containerNode, actualNode);
}
ShardTestKit.waitUntilLeader(shard);
final TransactionIdentifier transactionID = nextTransactionId();
- final NormalizedNode<?, ?> containerNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode containerNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
if (readWrite) {
shard.tell(prepareForwardedReadyTransaction(shard, transactionID, TestModel.TEST_PATH, containerNode, true),
testKit.getRef());
testKit.expectMsgClass(Duration.ofSeconds(5), CommitTransactionReply.class);
- final NormalizedNode<?, ?> actualNode = readStore(shard, TestModel.TEST_PATH);
+ final NormalizedNode actualNode = readStore(shard, TestModel.TEST_PATH);
assertEquals(TestModel.TEST_QNAME.getLocalName(), containerNode, actualNode);
}
testKit.expectMsgClass(CommitTransactionReply.class);
- final NormalizedNode<?, ?> actualNode = readStore(shard, TestModel.OUTER_LIST_PATH);
+ final NormalizedNode actualNode = readStore(shard, TestModel.OUTER_LIST_PATH);
assertEquals(TestModel.OUTER_LIST_QNAME.getLocalName(), mergeData, actualNode);
}
shard.tell(new CommitTransaction(txId, CURRENT_VERSION).toSerializable(), testKit.getRef());
testKit.expectMsgClass(CommitTransactionReply.class);
- final NormalizedNode<?, ?> actualNode = readStore(shard, TestModel.OUTER_LIST_PATH);
+ final NormalizedNode actualNode = readStore(shard, TestModel.OUTER_LIST_PATH);
assertEquals(TestModel.OUTER_LIST_QNAME.getLocalName(), mergeData, actualNode);
}
final Duration duration = Duration.ofSeconds(5);
final TransactionIdentifier transactionID = nextTransactionId();
- final NormalizedNode<?, ?> containerNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode containerNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
shard.tell(prepareBatchedModifications(transactionID, TestModel.TEST_PATH, containerNode, false),
testKit.getRef());
testKit.expectMsgClass(duration, ReadyTransactionReply.class);
shard.tell(new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
testKit.expectMsgClass(duration, CommitTransactionReply.class);
- final NormalizedNode<?, ?> actualNode = readStore(shard, TestModel.TEST_PATH);
+ final NormalizedNode actualNode = readStore(shard, TestModel.TEST_PATH);
assertEquals(TestModel.TEST_QNAME.getLocalName(), containerNode, actualNode);
}
shard.tell(new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
testKit.expectMsgClass(duration, CommitTransactionReply.class);
- final NormalizedNode<?, ?> node = readStore(shard, TestModel.TEST_PATH);
+ final NormalizedNode node = readStore(shard, TestModel.TEST_PATH);
// Since we're simulating an abort occurring during replication
// and before finish commit,
shard.tell(new CommitTransaction(transactionID2, CURRENT_VERSION).toSerializable(), testKit.getRef());
testKit.expectMsgClass(duration, CommitTransactionReply.class);
- final NormalizedNode<?, ?> node = readStore(shard, listNodePath);
+ final NormalizedNode node = readStore(shard, listNodePath);
assertNotNull(listNodePath + " not found", node);
}
testKit.expectMsgClass(duration, CommitTransactionReply.class);
- final NormalizedNode<?, ?> node = readStore(shard, TestModel.TEST2_PATH);
+ final NormalizedNode node = readStore(shard, TestModel.TEST2_PATH);
assertNotNull(TestModel.TEST2_PATH + " not found", node);
}
ShardTestKit.waitUntilLeader(shard);
writeToStore(shard, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- final NormalizedNode<?, ?> expectedRoot = readStore(shard, YangInstanceIdentifier.empty());
+ final NormalizedNode expectedRoot = readStore(shard, YangInstanceIdentifier.empty());
// Trigger creation of a snapshot by ensuring
final RaftActorContext raftActorContext = ((TestShard) shard.underlyingActor()).getRaftActorContext();
}
private static void awaitAndValidateSnapshot(final AtomicReference<CountDownLatch> latch,
- final AtomicReference<Object> savedSnapshot, final NormalizedNode<?, ?> expectedRoot)
+ final AtomicReference<Object> savedSnapshot, final NormalizedNode expectedRoot)
throws InterruptedException {
assertTrue("Snapshot saved", latch.get().await(5, TimeUnit.SECONDS));
savedSnapshot.set(null);
}
- private static void verifySnapshot(final Snapshot snapshot, final NormalizedNode<?, ?> expectedRoot) {
- final NormalizedNode<?, ?> actual = ((ShardSnapshotState)snapshot.getState()).getSnapshot().getRootNode().get();
+ private static void verifySnapshot(final Snapshot snapshot, final NormalizedNode expectedRoot) {
+ final NormalizedNode actual = ((ShardSnapshotState)snapshot.getState()).getSnapshot().getRootNode().get();
assertEquals("Root node", expectedRoot, actual);
}
commitTransaction(store, putTransaction);
- final NormalizedNode<?, ?> expected = readStore(store, YangInstanceIdentifier.empty());
+ final NormalizedNode expected = readStore(store, YangInstanceIdentifier.empty());
final DataTreeModification writeTransaction = store.takeSnapshot().newModification();
commitTransaction(store, writeTransaction);
- final NormalizedNode<?, ?> actual = readStore(store, YangInstanceIdentifier.empty());
+ final NormalizedNode actual = readStore(store, YangInstanceIdentifier.empty());
assertEquals(expected, actual);
}
final ActorRef transaction = newTransactionActor(RW, mockWriteTx, "testOnReceiveBatchedModifications");
YangInstanceIdentifier writePath = TestModel.TEST_PATH;
- NormalizedNode<?, ?> writeData = ImmutableContainerNodeBuilder.create()
+ NormalizedNode writeData = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
YangInstanceIdentifier mergePath = TestModel.OUTER_LIST_PATH;
- NormalizedNode<?, ?> mergeData = ImmutableContainerNodeBuilder.create()
+ NormalizedNode mergeData = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.OUTER_LIST_QNAME))
.build();
watcher.watch(transaction);
YangInstanceIdentifier writePath = TestModel.TEST_PATH;
- NormalizedNode<?, ?> writeData = ImmutableContainerNodeBuilder.create()
+ NormalizedNode writeData = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
watcher.watch(transaction);
YangInstanceIdentifier writePath = TestModel.TEST_PATH;
- NormalizedNode<?, ?> writeData = ImmutableContainerNodeBuilder.create()
+ NormalizedNode writeData = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
DOMStoreWriteTransaction writeTx1 = txChainProxy.newWriteOnlyTransaction();
- NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
writeTx1.write(TestModel.TEST_PATH, writeNode1);
writeTx1.ready();
expectBatchedModifications(txActorRef2, 1);
- final NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+ final NormalizedNode writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
final DOMStoreWriteTransaction writeTx2 = txChainProxy.newWriteOnlyTransaction();
DOMStoreWriteTransaction writeTx1 = txChainProxy.newReadWriteTransaction();
- NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
writeTx1.write(TestModel.TEST_PATH, writeNode1);
writeTx1.ready();
expectBatchedModifications(txActorRef2, 1);
- final NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+ final NormalizedNode writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
final DOMStoreWriteTransaction writeTx2 = txChainProxy.newReadWriteTransaction();
DOMStoreWriteTransaction writeTx1 = txChainProxy.newWriteOnlyTransaction();
- NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
writeTx1.write(TestModel.TEST_PATH, writeNode1);
txChainProxy.newWriteOnlyTransaction();
doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
- Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
+ Optional<NormalizedNode> readOptional = transactionProxy.read(
TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
assertFalse("NormalizedNode isPresent", readOptional.isPresent());
- NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
public void testReadWithPriorRecordingOperationSuccessful() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(actorRef, 1);
transactionProxy.write(TestModel.TEST_PATH, expectedNode);
- Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
+ Optional<NormalizedNode> readOptional = transactionProxy.read(
TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
assertTrue("NormalizedNode isPresent", readOptional.isPresent());
public void testExistsWithPriorRecordingOperationSuccessful() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(actorRef, 1);
dataStoreContextBuilder.shardBatchedModificationCount(1);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(actorRef, 1);
expectBatchedModificationsReady(actorRef);
- final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
final TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
final CountDownLatch readComplete = new CountDownLatch(1);
final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
com.google.common.util.concurrent.Futures.addCallback(transactionProxy.read(TestModel.TEST_PATH),
- new FutureCallback<Optional<NormalizedNode<?, ?>>>() {
+ new FutureCallback<Optional<NormalizedNode>>() {
@Override
- public void onSuccess(final Optional<NormalizedNode<?, ?>> result) {
+ public void onSuccess(final Optional<NormalizedNode> result) {
try {
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
} catch (Exception e) {
dataStoreContextBuilder.shardBatchedModificationCount(1);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(actorRef, 1);
public void testReadWrite() {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
public void testReadyWithReadWrite() {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModificationsReady(actorRef, true);
dataStoreContextBuilder.shardBatchedModificationCount(1).writeOnlyTransactionOptimizationsEnabled(true);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModificationsReady(actorRef, true);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectFailedBatchedModifications(actorRef);
expectReadyLocalTransaction(shardActorRef, true);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
expectReadyLocalTransaction(shardActorRef, true);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
return dataTree;
}
- private static DataTree createDataTree(final NormalizedNode<?, ?> readResponse) {
+ private static DataTree createDataTree(final NormalizedNode readResponse) {
DataTree dataTree = mock(DataTree.class);
DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class);
DataTreeModification dataTreeModification = mock(DataTreeModification.class);
@Test
public void testWriteCompletionForLocalShard() {
completeOperationLocal(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
@Test
public void testWriteThrottlingWhenShardFound() {
throttleOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectIncompleteBatchedModifications();
public void testWriteThrottlingWhenShardNotFound() {
// Confirm that there is no throttling when the Shard is not found
completeOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(2);
@Test
public void testWriteCompletion() {
completeOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(2);
@Test
public void testMergeThrottlingWhenShardFound() {
throttleOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectIncompleteBatchedModifications();
@Test
public void testMergeThrottlingWhenShardNotFound() {
completeOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(2);
@Test
public void testMergeCompletion() {
completeOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(2);
@Test
public void testMergeCompletionForLocalShard() {
completeOperationLocal(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
@Test
public void testReadCompletion() {
completeOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
doReturn(readDataReply(nodeToRead)).when(mockActorContext).executeOperationAsync(
any(ActorSelection.class), eqReadData(), any(Timeout.class));
@Test
public void testReadCompletionForLocalShard() {
- final NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
completeOperationLocal(transactionProxy -> {
transactionProxy.read(TestModel.TEST_PATH);
@Test
public void testExistsCompletionForLocalShard() {
- final NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
completeOperationLocal(transactionProxy -> {
transactionProxy.exists(TestModel.TEST_PATH);
public void testReadyThrottling() {
throttleOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(1);
@Test
public void testReadyThrottlingWithTwoTransactionContexts() {
throttleOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- NormalizedNode<?, ?> carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
expectBatchedModifications(2);
expectBatchedModifications(actorRef, shardBatchedModificationCount);
YangInstanceIdentifier writePath1 = TestModel.TEST_PATH;
- NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH;
- NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+ NormalizedNode writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
YangInstanceIdentifier writePath3 = TestModel.INNER_LIST_PATH;
- NormalizedNode<?, ?> writeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
+ NormalizedNode writeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH;
- NormalizedNode<?, ?> mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
YangInstanceIdentifier mergePath2 = TestModel.OUTER_LIST_PATH;
- NormalizedNode<?, ?> mergeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+ NormalizedNode mergeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
YangInstanceIdentifier mergePath3 = TestModel.INNER_LIST_PATH;
- NormalizedNode<?, ?> mergeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
+ NormalizedNode mergeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
YangInstanceIdentifier deletePath1 = TestModel.TEST_PATH;
YangInstanceIdentifier deletePath2 = TestModel.OUTER_LIST_PATH;
expectBatchedModifications(actorRef, shardBatchedModificationCount);
final YangInstanceIdentifier writePath1 = TestModel.TEST_PATH;
- final NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH;
- NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+ NormalizedNode writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
final YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH;
- final NormalizedNode<?, ?> mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
YangInstanceIdentifier mergePath2 = TestModel.INNER_LIST_PATH;
- NormalizedNode<?, ?> mergeNode2 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
+ NormalizedNode mergeNode2 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
final YangInstanceIdentifier deletePath = TestModel.OUTER_LIST_PATH;
transactionProxy.write(writePath1, writeNode1);
transactionProxy.write(writePath2, writeNode2);
- Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(writePath2).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> readOptional = transactionProxy.read(writePath2).get(5, TimeUnit.SECONDS);
assertTrue("NormalizedNode isPresent", readOptional.isPresent());
assertEquals("Response NormalizedNode", writeNode2, readOptional.get());
doReturn(schemaContext).when(mockActorContext).getSchemaContext();
doReturn(Sets.newHashSet("test", "cars")).when(configuration).getAllShardNames();
- NormalizedNode<?, ?> expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- NormalizedNode<?, ?> expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);
+ NormalizedNode expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);
setUpReadData("test", NormalizedNodeAggregatorTest.getRootNode(expectedNode1, schemaContext));
setUpReadData("cars", NormalizedNodeAggregatorTest.getRootNode(expectedNode2, schemaContext));
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
- Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
+ Optional<NormalizedNode> readOptional = transactionProxy.read(
YangInstanceIdentifier.empty()).get(5, TimeUnit.SECONDS);
assertTrue("NormalizedNode isPresent", readOptional.isPresent());
- NormalizedNode<?, ?> normalizedNode = readOptional.get();
+ NormalizedNode normalizedNode = readOptional.get();
- assertTrue("Expect value to be a Collection", normalizedNode.getValue() instanceof Collection);
+ assertTrue("Expect value to be a Collection", normalizedNode.body() instanceof Collection);
@SuppressWarnings("unchecked")
- Collection<NormalizedNode<?,?>> collection = (Collection<NormalizedNode<?,?>>) normalizedNode.getValue();
+ Collection<NormalizedNode> collection = (Collection<NormalizedNode>) normalizedNode.body();
- for (NormalizedNode<?,?> node : collection) {
+ for (NormalizedNode node : collection) {
assertTrue("Expected " + node + " to be a ContainerNode", node instanceof ContainerNode);
}
}
- private void setUpReadData(final String shardName, final NormalizedNode<?, ?> expectedNode) {
+ private void setUpReadData(final String shardName, final NormalizedNode expectedNode) {
ActorSystem actorSystem = getSystem();
ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
public class ShardSnapshotActorTest extends AbstractActorTest {
private static final InputOutputStreamFactory STREAM_FACTORY = InputOutputStreamFactory.simple();
- private static final NormalizedNode<?, ?> DATA = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ private static final NormalizedNode DATA = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
private static void testSerializeSnapshot(final String testName, final ShardDataTreeSnapshot snapshot,
final boolean withInstallSnapshot) throws Exception {
final ActorRef snapshotActor = getSystem().actorOf(ShardSnapshotActor.props(STREAM_FACTORY), testName);
kit.watch(snapshotActor);
- final NormalizedNode<?, ?> expectedRoot = snapshot.getRootNode().get();
+ final NormalizedNode expectedRoot = snapshot.getRootNode().get();
ByteArrayOutputStream installSnapshotStream = withInstallSnapshot ? new ByteArrayOutputStream() : null;
ShardSnapshotActor.requestSnapshot(snapshotActor, snapshot,
assertEquals("Deserialized snapshot type", snapshot.getClass(), deserialized.getClass());
- final Optional<NormalizedNode<?, ?>> maybeNode = deserialized.getRootNode();
+ final Optional<NormalizedNode> maybeNode = deserialized.getRootNode();
assertTrue("isPresent", maybeNode.isPresent());
assertEquals("Root node", expectedRoot, maybeNode.get());
}
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Sets;
-import java.net.URI;
import java.util.Collection;
import java.util.Set;
import org.junit.Assert;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
import org.opendaylight.controller.cluster.datastore.shardstrategy.ModuleShardStrategy;
import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategy;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
public abstract class ConfigurationImplBaseTest {
private static final MemberName MEMBER_1 = MemberName.forName("member-1");
@Test
public void testAddModuleShardConfiguration() throws Exception {
- URI namespace = new URI("urn:opendaylight:test:oven");
+ XMLNamespace namespace = XMLNamespace.of("urn:opendaylight:test:oven");
String moduleName = "oven";
String shardName = "oven-shard";
String shardStrategyName = ModuleShardStrategy.NAME;
ImmutableSortedSet.copyOf(configuration.getMembersFromShardName(shardName)));
assertEquals("getShardNameForModule", shardName, configuration.getShardNameForModule(moduleName));
assertEquals("getModuleNameFromNameSpace", moduleName,
- configuration.getModuleNameFromNameSpace(namespace.toASCIIString()));
+ configuration.getModuleNameFromNameSpace(namespace.toString()));
assertEquals("getAllShardNames", ImmutableSortedSet.of("people-1", "cars-1", "test-1", "default", shardName),
ImmutableSortedSet.copyOf(configuration.getAllShardNames()));
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Sets;
-import java.net.URI;
import java.util.Collection;
import java.util.Set;
import org.junit.Assert;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
import org.opendaylight.controller.cluster.datastore.shardstrategy.ModuleShardStrategy;
import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategy;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
public class ConfigurationImplTest {
private static final MemberName MEMBER_1 = MemberName.forName("member-1");
@Test
public void testAddModuleShardConfiguration() throws Exception {
- URI namespace = new URI("urn:opendaylight:test:oven");
+ XMLNamespace namespace = XMLNamespace.of("urn:opendaylight:test:oven");
String moduleName = "oven";
String shardName = "oven-shard";
String shardStrategyName = ModuleShardStrategy.NAME;
ImmutableSortedSet.copyOf(configuration.getMembersFromShardName(shardName)));
assertEquals("getShardNameForModule", shardName, configuration.getShardNameForModule(moduleName));
assertEquals("getModuleNameFromNameSpace", moduleName,
- configuration.getModuleNameFromNameSpace(namespace.toASCIIString()));
+ configuration.getModuleNameFromNameSpace(namespace.toString()));
assertEquals("getAllShardNames", ImmutableSortedSet.of("people-1", "cars-1", "test-1", "default", shardName),
ImmutableSortedSet.copyOf(configuration.getAllShardNames()));
@Test
public void testSerialization() {
YangInstanceIdentifier writePath = TestModel.TEST_PATH;
- NormalizedNode<?, ?> writeData = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
+ NormalizedNode writeData = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
YangInstanceIdentifier mergePath = TestModel.OUTER_LIST_PATH;
- NormalizedNode<?, ?> mergeData = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
+ NormalizedNode mergeData = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(TestModel.OUTER_LIST_QNAME)).build();
YangInstanceIdentifier deletePath = TestModel.TEST_PATH;
@Test
public void testSerialization() {
- NormalizedNode<?, ?> data = ImmutableContainerNodeBuilder.create()
+ NormalizedNode data = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
cohort.commit();
}
- protected Optional<NormalizedNode<?, ?>> readData(final YangInstanceIdentifier path) throws Exception {
+ protected Optional<NormalizedNode> readData(final YangInstanceIdentifier path) throws Exception {
+ // FIXME: close the transaction
DOMStoreReadTransaction transaction = store.newReadOnlyTransaction();
- ListenableFuture<Optional<NormalizedNode<?, ?>>> future = transaction.read(path);
+ ListenableFuture<Optional<NormalizedNode>> future = transaction.read(path);
return future.get();
}
}
commitTransaction(writeTransaction);
// Check if it's in the datastore
- Optional<NormalizedNode<?, ?>> data = readData(TestModel.TEST_PATH);
+ Optional<NormalizedNode> data = readData(TestModel.TEST_PATH);
Assert.assertTrue(data.isPresent());
// Delete stuff from the datastore
commitTransaction(writeTransaction);
//Check if it's in the datastore
- Optional<NormalizedNode<?,?>> data = readData(TestModel.TEST_PATH);
+ Optional<NormalizedNode> data = readData(TestModel.TEST_PATH);
Assert.assertTrue(data.isPresent());
}
@Test
public void testSerialization() {
YangInstanceIdentifier path = TestModel.TEST_PATH;
- NormalizedNode<?, ?> data = ImmutableContainerNodeBuilder.create()
+ NormalizedNode data = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
compositeModification.apply(transaction);
commitTransaction(transaction);
- Optional<NormalizedNode<?, ?>> data = readData(TestModel.TEST_PATH);
+ Optional<NormalizedNode> data = readData(TestModel.TEST_PATH);
assertNotNull(data.get());
- assertEquals(TestModel.TEST_QNAME, data.get().getNodeType());
+ assertEquals(TestModel.TEST_QNAME, data.get().getIdentifier().getNodeType());
}
@Test
public void testSerialization() {
YangInstanceIdentifier writePath = TestModel.TEST_PATH;
- NormalizedNode<?, ?> writeData = ImmutableContainerNodeBuilder.create()
+ NormalizedNode writeData = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
YangInstanceIdentifier mergePath = TestModel.OUTER_LIST_PATH;
- NormalizedNode<?, ?> mergeData = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
+ NormalizedNode mergeData = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(TestModel.OUTER_LIST_QNAME)).build();
YangInstanceIdentifier deletePath = TestModel.TEST_PATH;
commitTransaction(writeTransaction);
//Check if it's in the datastore
- Optional<NormalizedNode<?,?>> data = readData(TestModel.TEST_PATH);
+ Optional<NormalizedNode> data = readData(TestModel.TEST_PATH);
Assert.assertTrue(data.isPresent());
}
@Test
public void testSerialization() {
YangInstanceIdentifier path = TestModel.TEST_PATH;
- NormalizedNode<?, ?> data = ImmutableContainerNodeBuilder.create()
+ NormalizedNode data = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
public void setUp() {
setUpStatic();
final YangInstanceIdentifier writePath = TestModel.TEST_PATH;
- final NormalizedNode<?, ?> writeData = ImmutableContainerNodeBuilder.create()
+ final NormalizedNode writeData = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
candidate = DataTreeCandidates.fromNormalizedNode(writePath, writeData);
YangInstanceIdentifier leafSetEntryPath = YangInstanceIdentifier.builder(TestModel.TEST_PATH).node(LEAF_SET)
.node(entryPathArg).build();
- NormalizedNode<?, ?> leafSetEntryNode = Builders.leafSetEntryBuilder().withNodeIdentifier(entryPathArg)
+ NormalizedNode leafSetEntryNode = Builders.leafSetEntryBuilder().withNodeIdentifier(entryPathArg)
.withValue("one").build();
candidate = DataTreeCandidates.fromNormalizedNode(leafSetEntryPath, leafSetEntryNode);
LeafSetEntryNode leafSetEntryNode = Builders.leafSetEntryBuilder().withNodeIdentifier(entryPathArg)
.withValue("one").build();
- NormalizedNode<?, ?> leafSetNode = Builders.leafSetBuilder().withNodeIdentifier(
+ NormalizedNode leafSetNode = Builders.leafSetBuilder().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(LEAF_SET)).withChild(leafSetEntryNode).build();
candidate = DataTreeCandidates.fromNormalizedNode(leafSetPath, leafSetNode);
LeafSetEntryNode leafSetEntryNode = Builders.leafSetEntryBuilder().withNodeIdentifier(entryPathArg)
.withValue("one").build();
- NormalizedNode<?, ?> leafSetNode = Builders.orderedLeafSetBuilder().withNodeIdentifier(
+ NormalizedNode leafSetNode = Builders.orderedLeafSetBuilder().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(LEAF_SET)).withChild(leafSetEntryNode).build();
candidate = DataTreeCandidates.fromNormalizedNode(leafSetPath, leafSetNode);
@Test
public void testShardDataTreeSnapshotWithNoMetadata() throws Exception {
- NormalizedNode<?, ?> expectedNode = ImmutableContainerNodeBuilder.create()
+ NormalizedNode expectedNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
deserialized = ShardDataTreeSnapshot.deserialize(in).getSnapshot();
}
- Optional<NormalizedNode<?, ?>> actualNode = deserialized.getRootNode();
+ Optional<NormalizedNode> actualNode = deserialized.getRootNode();
assertTrue("rootNode present", actualNode.isPresent());
assertEquals("rootNode", expectedNode, actualNode.get());
assertEquals("Deserialized type", MetadataShardDataTreeSnapshot.class, deserialized.getClass());
@Test
public void testShardDataTreeSnapshotWithMetadata() throws Exception {
- NormalizedNode<?, ?> expectedNode = ImmutableContainerNodeBuilder.create()
+ NormalizedNode expectedNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
deserialized = ShardDataTreeSnapshot.deserialize(in).getSnapshot();
}
- Optional<NormalizedNode<?, ?>> actualNode = deserialized.getRootNode();
+ Optional<NormalizedNode> actualNode = deserialized.getRootNode();
assertTrue("rootNode present", actualNode.isPresent());
assertEquals("rootNode", expectedNode, actualNode.get());
assertEquals("Deserialized type", MetadataShardDataTreeSnapshot.class, deserialized.getClass());
@Test
public void testSerialization() {
- NormalizedNode<?, ?> expectedNode = ImmutableContainerNodeBuilder.create()
+ NormalizedNode expectedNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.Uninterruptibles;
-import java.net.URI;
import java.time.Duration;
import java.util.AbstractMap;
import java.util.Arrays;
import org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor;
import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.slf4j.Logger;
.persistent(false).build();
Shard.Builder shardBuilder = Shard.builder();
- ModuleShardConfiguration config = new ModuleShardConfiguration(URI.create("foo-ns"), "foo-module",
+ ModuleShardConfiguration config = new ModuleShardConfiguration(XMLNamespace.of("foo-ns"), "foo-module",
"foo", null, members("member-1", "member-5", "member-6"));
shardManager.tell(new CreateShard(config, shardBuilder, datastoreContext), kit.getRef());
shardManager.tell(new UpdateSchemaContext(TEST_SCHEMA_CONTEXT), ActorRef.noSender());
Shard.Builder shardBuilder = Shard.builder();
- ModuleShardConfiguration config = new ModuleShardConfiguration(URI.create("foo-ns"), "foo-module",
+ ModuleShardConfiguration config = new ModuleShardConfiguration(XMLNamespace.of("foo-ns"), "foo-module",
"foo", null, members("member-5", "member-6"));
shardManager.tell(new CreateShard(config, shardBuilder, null), kit.getRef());
Shard.Builder shardBuilder = Shard.builder();
- ModuleShardConfiguration config = new ModuleShardConfiguration(URI.create("foo-ns"), "foo-module",
+ ModuleShardConfiguration config = new ModuleShardConfiguration(XMLNamespace.of("foo-ns"), "foo-module",
"foo", null, members("member-1"));
shardManager.tell(new CreateShard(config, shardBuilder, null), kit.getRef());
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
public class MockDataTreeChangeListener implements DOMDataTreeChangeListener {
for (int i = 0; i < expPaths.length; i++) {
final DataTreeCandidate candidate = changeList.get(i);
- final Optional<NormalizedNode<?, ?>> maybeDataAfter = candidate.getRootNode().getDataAfter();
+ final Optional<NormalizedNode> maybeDataAfter = candidate.getRootNode().getDataAfter();
if (!maybeDataAfter.isPresent()) {
fail(String.format("Change %d does not contain data after. Actual: %s", i + 1,
candidate.getRootNode()));
}
- final NormalizedNode<?, ?> dataAfter = maybeDataAfter.get();
+ final NormalizedNode dataAfter = maybeDataAfter.get();
final Optional<YangInstanceIdentifier> relativePath = expPaths[i].relativeTo(candidate.getRootPath());
if (!relativePath.isPresent()) {
assertEquals(String.format("Change %d does not contain %s. Actual: %s", i + 1, expPaths[i],
dataAfter), expPaths[i].getLastPathArgument(), dataAfter.getIdentifier());
} else {
- NormalizedNode<?, ?> nextChild = dataAfter;
+ NormalizedNode nextChild = dataAfter;
for (PathArgument pathArg: relativePath.get().getPathArguments()) {
boolean found = false;
- if (nextChild instanceof NormalizedNodeContainer) {
- Optional<NormalizedNode<?, ?>> maybeChild = ((NormalizedNodeContainer)nextChild)
- .getChild(pathArg);
+ if (nextChild instanceof DistinctNodeContainer) {
+ Optional<NormalizedNode> maybeChild = ((DistinctNodeContainer)nextChild)
+ .findChildByArg(pathArg);
if (maybeChild.isPresent()) {
found = true;
nextChild = maybeChild.get();
public void testAggregate() throws InterruptedException, ExecutionException,
DataValidationFailedException {
EffectiveModelContext schemaContext = SchemaContextHelper.full();
- NormalizedNode<?, ?> expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- NormalizedNode<?, ?> expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);
+ NormalizedNode expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);
- Optional<NormalizedNode<?, ?>> optional = NormalizedNodeAggregator.aggregate(YangInstanceIdentifier.empty(),
+ Optional<NormalizedNode> optional = NormalizedNodeAggregator.aggregate(YangInstanceIdentifier.empty(),
ImmutableList.of(
- Optional.<NormalizedNode<?, ?>>of(getRootNode(expectedNode1, schemaContext)),
- Optional.<NormalizedNode<?, ?>>of(getRootNode(expectedNode2, schemaContext))),
+ Optional.<NormalizedNode>of(getRootNode(expectedNode1, schemaContext)),
+ Optional.<NormalizedNode>of(getRootNode(expectedNode2, schemaContext))),
schemaContext, LogicalDatastoreType.CONFIGURATION);
- NormalizedNode<?,?> normalizedNode = optional.get();
+ NormalizedNode normalizedNode = optional.get();
- assertTrue("Expect value to be a Collection", normalizedNode.getValue() instanceof Collection);
+ assertTrue("Expect value to be a Collection", normalizedNode.body() instanceof Collection);
@SuppressWarnings("unchecked")
- Collection<NormalizedNode<?,?>> collection = (Collection<NormalizedNode<?,?>>) normalizedNode.getValue();
+ Collection<NormalizedNode> collection = (Collection<NormalizedNode>) normalizedNode.body();
- for (NormalizedNode<?,?> node : collection) {
+ for (NormalizedNode node : collection) {
assertTrue("Expected " + node + " to be a ContainerNode", node instanceof ContainerNode);
}
}
- public static NormalizedNode<?, ?> getRootNode(final NormalizedNode<?, ?> moduleNode,
+ public static NormalizedNode getRootNode(final NormalizedNode moduleNode,
final EffectiveModelContext schemaContext) throws ExecutionException, InterruptedException {
try (InMemoryDOMDataStore store = new InMemoryDOMDataStore("test", Executors.newSingleThreadExecutor())) {
store.onModelContextUpdated(schemaContext);
DOMStoreWriteTransaction writeTransaction = store.newWriteOnlyTransaction();
- writeTransaction.merge(YangInstanceIdentifier.of(moduleNode.getNodeType()), moduleNode);
+ writeTransaction.merge(YangInstanceIdentifier.of(moduleNode.getIdentifier().getNodeType()), moduleNode);
DOMStoreThreePhaseCommitCohort ready = writeTransaction.ready();
DOMStoreReadTransaction readTransaction = store.newReadOnlyTransaction();
- FluentFuture<Optional<NormalizedNode<?, ?>>> read = readTransaction.read(YangInstanceIdentifier.empty());
+ FluentFuture<Optional<NormalizedNode>> read = readTransaction.read(YangInstanceIdentifier.empty());
- Optional<NormalizedNode<?, ?>> nodeOptional = read.get();
+ Optional<NormalizedNode> nodeOptional = read.get();
return nodeOptional.get();
}
}
- public static NormalizedNode<?,?> findChildWithQName(final Collection<NormalizedNode<?, ?>> collection,
+ public static NormalizedNode findChildWithQName(final Collection<NormalizedNode> collection,
final QName qname) {
- for (NormalizedNode<?, ?> node : collection) {
- if (node.getNodeType().equals(qname)) {
+ for (NormalizedNode node : collection) {
+ if (node.getIdentifier().getNodeType().equals(qname)) {
return node;
}
}
@Test
public void testMerge() {
- NormalizedNode<?, ?> normalizedNode = CarsModel.create();
+ NormalizedNode normalizedNode = CarsModel.create();
YangInstanceIdentifier path = CarsModel.BASE_PATH;
pruningDataTreeModification.merge(path, normalizedNode);
@Test
public void testMergeWithInvalidNamespace() throws DataValidationFailedException {
- NormalizedNode<?, ?> normalizedNode = PeopleModel.emptyContainer();
+ NormalizedNode normalizedNode = PeopleModel.emptyContainer();
YangInstanceIdentifier path = PeopleModel.BASE_PATH;
pruningDataTreeModification.merge(path, normalizedNode);
new YangInstanceIdentifier.NodeIdentifier(AUG_CONTAINER)).withChild(
ImmutableNodes.containerNode(AUG_INNER_CONTAINER)).build();
- DataContainerChild<?, ?> outerNode = outerNode(outerNodeEntry(1, innerNode("one", "two")));
+ DataContainerChild outerNode = outerNode(outerNodeEntry(1, innerNode("one", "two")));
ContainerNode normalizedNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outerNode)
.withChild(augContainer).withChild(ImmutableNodes.leafNode(AUG_QNAME, "aug")).build();
ContainerNode prunedNode = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outerNode).build();
- Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(path);
+ Optional<NormalizedNode> actual = dataTree.takeSnapshot().readNode(path);
assertTrue("After pruning present", actual.isPresent());
assertEquals("After pruning", prunedNode, actual.get());
}
@Test
public void testMergeWithValidNamespaceAndInvalidNodeName() throws DataValidationFailedException {
- NormalizedNode<?, ?> normalizedNode = ImmutableNodes.containerNode(INVALID_TEST_QNAME);
+ NormalizedNode normalizedNode = ImmutableNodes.containerNode(INVALID_TEST_QNAME);
YangInstanceIdentifier path = INVALID_TEST_PATH;
pruningDataTreeModification.merge(path, normalizedNode);
@Test
public void testWrite() {
- NormalizedNode<?, ?> normalizedNode = CarsModel.create();
+ NormalizedNode normalizedNode = CarsModel.create();
YangInstanceIdentifier path = CarsModel.BASE_PATH;
pruningDataTreeModification.write(path, normalizedNode);
localDataTree.validate(mod);
localDataTree.commit(localDataTree.prepare(mod));
- NormalizedNode<?, ?> normalizedNode = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.empty()).get();
+ NormalizedNode normalizedNode = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.empty()).get();
pruningDataTreeModification.write(YangInstanceIdentifier.empty(), normalizedNode);
dataTree.commit(getCandidate());
- Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.empty());
+ Optional<NormalizedNode> actual = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.empty());
assertTrue("Root present", actual.isPresent());
assertEquals("Root node", normalizedNode, actual.get());
}
final Shard mockShard = Mockito.mock(Shard.class);
ShardDataTree shardDataTree = new ShardDataTree(mockShard, SCHEMA_CONTEXT, TreeType.CONFIGURATION);
- NormalizedNode<?, ?> root = shardDataTree.readNode(YangInstanceIdentifier.empty()).get();
+ NormalizedNode root = shardDataTree.readNode(YangInstanceIdentifier.empty()).get();
- NormalizedNode<?, ?> normalizedNode = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(root.getNodeType())).withChild(
+ NormalizedNode normalizedNode = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
+ new YangInstanceIdentifier.NodeIdentifier(root.getIdentifier().getNodeType())).withChild(
ImmutableNodes.containerNode(AUG_CONTAINER)).build();
pruningDataTreeModification.write(YangInstanceIdentifier.empty(), normalizedNode);
dataTree.commit(getCandidate());
- Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.empty());
+ Optional<NormalizedNode> actual = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.empty());
assertEquals("Root present", true, actual.isPresent());
assertEquals("Root node", root, actual.get());
@Test
public void testWriteWithInvalidNamespace() throws DataValidationFailedException {
- NormalizedNode<?, ?> normalizedNode = PeopleModel.emptyContainer();
+ NormalizedNode normalizedNode = PeopleModel.emptyContainer();
YangInstanceIdentifier path = PeopleModel.BASE_PATH;
pruningDataTreeModification.write(path, normalizedNode);
new YangInstanceIdentifier.NodeIdentifier(AUG_CONTAINER)).withChild(
ImmutableNodes.containerNode(AUG_INNER_CONTAINER)).build();
- DataContainerChild<?, ?> outerNode = outerNode(outerNodeEntry(1, innerNode("one", "two")));
+ DataContainerChild outerNode = outerNode(outerNodeEntry(1, innerNode("one", "two")));
ContainerNode normalizedNode = ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outerNode)
.withChild(augContainer).withChild(ImmutableNodes.leafNode(AUG_QNAME, "aug"))
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outerNode)
.withChild(ImmutableNodes.leafNode(NAME_QNAME, "name")).build();
- Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(path);
+ Optional<NormalizedNode> actual = dataTree.takeSnapshot().readNode(path);
assertTrue("After pruning present", actual.isPresent());
assertEquals("After pruning", prunedNode, actual.get());
}
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.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
}
- public static NormalizedNode<?, ?> create() {
+ public static ContainerNode create() {
// Create a list builder
- CollectionNodeBuilder<MapEntryNode, MapNode> cars =
+ CollectionNodeBuilder<MapEntryNode, SystemMapNode> cars =
ImmutableMapNodeBuilder.create().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(
- CAR_QNAME));
+ new YangInstanceIdentifier.NodeIdentifier(CAR_QNAME));
// Create an entry for the car altima
MapEntryNode altima =
}
- public static NormalizedNode<?, ?> createEmptyCarsList() {
+ public static NormalizedNode createEmptyCarsList() {
return newCarsNode(newCarsMapNode());
}
}
public static MapNode newCarsMapNode(final MapEntryNode... carEntries) {
- CollectionNodeBuilder<MapEntryNode, MapNode> builder = ImmutableMapNodeBuilder.create()
+ CollectionNodeBuilder<MapEntryNode, SystemMapNode> builder = ImmutableMapNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(CAR_QNAME));
for (MapEntryNode e : carEntries) {
builder.withChild(e);
return builder.build();
}
- public static NormalizedNode<?, ?> emptyContainer() {
+ public static ContainerNode emptyContainer() {
return ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(BASE_QNAME))
.build();
}
- public static NormalizedNode<?, ?> newCarMapNode() {
+ public static SystemMapNode newCarMapNode() {
return ImmutableNodes.mapNodeBuilder(CAR_QNAME).build();
}
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
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.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> familyContainerBuilder =
ImmutableContainerNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(FAMILY_QNAME));
- final CollectionNodeBuilder<MapEntryNode, MapNode> childrenBuilder = mapNodeBuilder(CHILDREN_QNAME);
+ final CollectionNodeBuilder<MapEntryNode, SystemMapNode> childrenBuilder = mapNodeBuilder(CHILDREN_QNAME);
final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode>
firstChildBuilder = mapEntryBuilder(CHILDREN_QNAME, CHILD_NUMBER_QNAME, FIRST_CHILD_ID);
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.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.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
}
- public static NormalizedNode<?, ?> create() {
+ public static ContainerNode create() {
// Create a list builder
- CollectionNodeBuilder<MapEntryNode, MapNode> cars =
+ CollectionNodeBuilder<MapEntryNode, SystemMapNode> cars =
ImmutableMapNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(
PERSON_QNAME));
}
- public static NormalizedNode<?, ?> emptyContainer() {
+ public static ContainerNode emptyContainer() {
return ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(BASE_QNAME))
.build();
}
- public static NormalizedNode<?, ?> newPersonMapNode() {
+ public static SystemMapNode newPersonMapNode() {
return ImmutableNodes.mapNodeBuilder(PERSON_QNAME).build();
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
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.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
return YangParserTestUtils.parseYangResource(DATASTORE_TEST_YANG);
}
- public static DataContainerChild<?, ?> outerMapNode() {
+ public static DataContainerChild outerMapNode() {
return ImmutableNodes.mapNodeBuilder(OUTER_LIST_QNAME).build();
}
- public static DataContainerChild<?, ?> outerNode(final int... ids) {
- CollectionNodeBuilder<MapEntryNode, MapNode> outer = ImmutableNodes.mapNodeBuilder(OUTER_LIST_QNAME);
+ public static DataContainerChild outerNode(final int... ids) {
+ CollectionNodeBuilder<MapEntryNode, SystemMapNode> outer = ImmutableNodes.mapNodeBuilder(OUTER_LIST_QNAME);
for (int id: ids) {
outer.addChild(ImmutableNodes.mapEntry(OUTER_LIST_QNAME, ID_QNAME, id));
}
return outer.build();
}
- public static DataContainerChild<?, ?> outerNode(final MapEntryNode... entries) {
- CollectionNodeBuilder<MapEntryNode, MapNode> outer = ImmutableNodes.mapNodeBuilder(OUTER_LIST_QNAME);
+ public static DataContainerChild outerNode(final MapEntryNode... entries) {
+ CollectionNodeBuilder<MapEntryNode, SystemMapNode> outer = ImmutableNodes.mapNodeBuilder(OUTER_LIST_QNAME);
for (MapEntryNode e: entries) {
outer.addChild(e);
}
return outer.build();
}
- public static DataContainerChild<?, ?> innerNode(final String... names) {
- CollectionNodeBuilder<MapEntryNode, MapNode> outer = ImmutableNodes.mapNodeBuilder(INNER_LIST_QNAME);
+ public static DataContainerChild innerNode(final String... names) {
+ CollectionNodeBuilder<MapEntryNode, SystemMapNode> outer = ImmutableNodes.mapNodeBuilder(INNER_LIST_QNAME);
for (String name: names) {
outer.addChild(ImmutableNodes.mapEntry(INNER_LIST_QNAME, NAME_QNAME, name));
}
return outer.build();
}
- public static MapEntryNode outerNodeEntry(final int id, final DataContainerChild<?, ?> inner) {
+ public static MapEntryNode outerNodeEntry(final int id, final DataContainerChild inner) {
return ImmutableNodes.mapEntryBuilder(OUTER_LIST_QNAME, ID_QNAME, id).addChild(inner).build();
}
- public static NormalizedNode<?, ?> testNodeWithOuter(final int... ids) {
+ public static NormalizedNode testNodeWithOuter(final int... ids) {
return testNodeWithOuter(outerNode(ids));
}
- public static NormalizedNode<?, ?> testNodeWithOuter(final DataContainerChild<?, ?> outer) {
+ public static NormalizedNode testNodeWithOuter(final DataContainerChild outer) {
return ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outer).build();
}
}
protected static String extractOwner(final LeafNode<?> ownerLeaf) {
- return ownerLeaf.getValue().toString();
+ return ownerLeaf.body().toString();
}
-
}
import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListenerRegistration;
import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.clustering.entity.owners.rev150804.EntityOwners;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
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;
return Optional.empty();
}
- Optional<NormalizedNode<?, ?>> entityNode = dataTree.takeSnapshot().readNode(
+ Optional<NormalizedNode> entityNode = dataTree.takeSnapshot().readNode(
entityPath(forEntity.getType(), forEntity.getIdentifier()));
if (!entityNode.isPresent()) {
return Optional.empty();
// Check if there are any candidates, if there are none we do not really have ownership state
final MapEntryNode entity = (MapEntryNode) entityNode.get();
- final Optional<DataContainerChild<? extends PathArgument, ?>> optionalCandidates =
- entity.getChild(CANDIDATE_NODE_ID);
+ final Optional<DataContainerChild> optionalCandidates = entity.findChildByArg(CANDIDATE_NODE_ID);
final boolean hasCandidates = optionalCandidates.isPresent()
- && ((MapNode) optionalCandidates.get()).getValue().size() > 0;
+ && ((MapNode) optionalCandidates.get()).body().size() > 0;
if (!hasCandidates) {
return Optional.empty();
}
MemberName localMemberName = context.getCurrentMemberName();
- Optional<DataContainerChild<? extends PathArgument, ?>> ownerLeaf = entity.getChild(ENTITY_OWNER_NODE_ID);
- String owner = ownerLeaf.isPresent() ? ownerLeaf.get().getValue().toString() : null;
+ Optional<DataContainerChild> ownerLeaf = entity.findChildByArg(ENTITY_OWNER_NODE_ID);
+ String owner = ownerLeaf.isPresent() ? ownerLeaf.get().body().toString() : null;
boolean hasOwner = !Strings.isNullOrEmpty(owner);
boolean isOwner = hasOwner && localMemberName.getName().equals(owner);
String newOwner = extractOwner(ownerLeaf);
String origOwner = null;
- Optional<NormalizedNode<?, ?>> dataBefore = changeRoot.getDataBefore();
+ Optional<NormalizedNode> dataBefore = changeRoot.getDataBefore();
if (dataBefore.isPresent()) {
origOwner = extractOwner((LeafNode<?>) changeRoot.getDataBefore().get());
}
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedMapNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUserMapNodeBuilder;
/**
* Utility methods for entity-owners yang model.
return NodeIdentifierWithPredicates.of(Candidate.QNAME, CANDIDATE_NAME_QNAME, candidateName);
}
- static NormalizedNode<?, ?> entityOwnersWithCandidate(final String entityType,
+ static NormalizedNode entityOwnersWithCandidate(final String entityType,
final YangInstanceIdentifier entityId, final String candidateName) {
return entityOwnersWithEntityTypeEntry(entityTypeEntryWithEntityEntry(entityType,
entityEntryWithCandidateEntry(entityId, candidateName)));
}
static MapNode candidateEntry(final String candidateName) {
- return ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(Candidate.QNAME))
+ return ImmutableUserMapNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(Candidate.QNAME))
.addChild(candidateMapEntry(candidateName)).build();
}
import org.opendaylight.controller.cluster.raft.VotingState;
import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
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;
private void onRegisterCandidateLocal(final RegisterCandidateLocal registerCandidate) {
LOG.debug("{}: onRegisterCandidateLocal: {}", persistenceId(), registerCandidate);
- NormalizedNode<?, ?> entityOwners = entityOwnersWithCandidate(registerCandidate.getEntity().getType(),
+ NormalizedNode entityOwners = entityOwnersWithCandidate(registerCandidate.getEntity().getType(),
registerCandidate.getEntity().getIdentifier(), localMemberName.getName());
commitCoordinator.commitModification(new MergeModification(ENTITY_OWNERS_PATH, entityOwners), this);
getSender().tell(SuccessReply.INSTANCE, getSelf());
searchForEntities((entityTypeNode, entityNode) -> {
- Optional<DataContainerChild<?, ?>> possibleType = entityTypeNode.getChild(ENTITY_TYPE_NODE_ID);
- String entityType = possibleType.isPresent() ? possibleType.get().getValue().toString() : null;
+ String entityType = entityTypeNode.findChildByArg(ENTITY_TYPE_NODE_ID)
+ .map(child -> child.body().toString())
+ .orElse(null);
if (registerListener.getEntityType().equals(entityType)) {
final boolean hasOwner;
final boolean isOwner;
- Optional<DataContainerChild<?, ?>> possibleOwner = entityNode.getChild(ENTITY_OWNER_NODE_ID);
+ Optional<DataContainerChild> possibleOwner = entityNode.findChildByArg(ENTITY_OWNER_NODE_ID);
if (possibleOwner.isPresent()) {
- isOwner = localMemberName.getName().equals(possibleOwner.get().getValue().toString());
+ isOwner = localMemberName.getName().equals(possibleOwner.get().body().toString());
hasOwner = true;
} else {
isOwner = false;
}
DOMEntity entity = new DOMEntity(entityType,
- (YangInstanceIdentifier) entityNode.getChild(ENTITY_ID_NODE_ID).get().getValue());
+ (YangInstanceIdentifier) entityNode.findChildByArg(ENTITY_ID_NODE_ID).get().body());
listenerSupport.notifyEntityOwnershipListener(entity, false, isOwner, hasOwner,
registerListener.getListener());
private void notifyAllListeners() {
searchForEntities((entityTypeNode, entityNode) -> {
- Optional<DataContainerChild<?, ?>> possibleType = entityTypeNode.getChild(ENTITY_TYPE_NODE_ID);
+ Optional<DataContainerChild> possibleType = entityTypeNode.findChildByArg(ENTITY_TYPE_NODE_ID);
if (possibleType.isPresent()) {
final boolean hasOwner;
final boolean isOwner;
- Optional<DataContainerChild<?, ?>> possibleOwner = entityNode.getChild(ENTITY_OWNER_NODE_ID);
+ Optional<DataContainerChild> possibleOwner = entityNode.findChildByArg(ENTITY_OWNER_NODE_ID);
if (possibleOwner.isPresent()) {
- isOwner = localMemberName.getName().equals(possibleOwner.get().getValue().toString());
+ isOwner = localMemberName.getName().equals(possibleOwner.get().body().toString());
hasOwner = true;
} else {
isOwner = false;
hasOwner = false;
}
- DOMEntity entity = new DOMEntity(possibleType.get().getValue().toString(),
- (YangInstanceIdentifier) entityNode.getChild(ENTITY_ID_NODE_ID).get().getValue());
+ DOMEntity entity = new DOMEntity(possibleType.get().body().toString(),
+ (YangInstanceIdentifier) entityNode.findChildByArg(ENTITY_ID_NODE_ID).get().body());
listenerSupport.notifyEntityOwnershipListeners(entity, isOwner, isOwner, hasOwner);
}
.node(ENTITY_OWNER_NODE_ID).build();
Optional<String> possibleOwner =
- entityNode.getChild(ENTITY_OWNER_NODE_ID).map(node -> node.getValue().toString());
+ entityNode.findChildByArg(ENTITY_OWNER_NODE_ID).map(node -> node.body().toString());
String newOwner = newOwner(possibleOwner.orElse(null), getCandidateNames(entityNode),
getEntityOwnerElectionStrategy(entityPath));
}
private static Collection<String> getCandidateNames(final MapEntryNode entity) {
- return entity.getChild(CANDIDATE_NODE_ID).map(child -> {
- Collection<MapEntryNode> candidates = ((MapNode) child).getValue();
+ return entity.findChildByArg(CANDIDATE_NODE_ID).map(child -> {
+ Collection<MapEntryNode> candidates = ((MapNode) child).body();
Collection<String> candidateNames = new ArrayList<>(candidates.size());
for (MapEntryNode candidate: candidates) {
- candidateNames.add(candidate.getChild(CANDIDATE_NAME_NODE_ID).get().getValue().toString());
+ candidateNames.add(candidate.findChildByArg(CANDIDATE_NAME_NODE_ID).get().body().toString());
}
return candidateNames;
}).orElse(ImmutableList.of());
LOG.debug("{}: Searching for entities owned by {}", persistenceId(), ownedBy);
searchForEntities((entityTypeNode, entityNode) -> {
- Optional<DataContainerChild<? extends PathArgument, ?>> possibleOwner =
- entityNode.getChild(ENTITY_OWNER_NODE_ID);
- String currentOwner = possibleOwner.isPresent() ? possibleOwner.get().getValue().toString() : "";
+ String currentOwner = entityNode.findChildByArg(ENTITY_OWNER_NODE_ID)
+ .map(child -> child.body().toString())
+ .orElse("");
if (ownedBy.contains(currentOwner)) {
walker.onEntity(entityTypeNode, entityNode);
}
}
private static boolean hasCandidate(final MapEntryNode entity, final MemberName candidateName) {
- return entity.getChild(CANDIDATE_NODE_ID)
- .flatMap(child -> ((MapNode)child).getChild(candidateNodeKey(candidateName.getName())))
+ return entity.findChildByArg(CANDIDATE_NODE_ID)
+ .flatMap(child -> ((MapNode)child).findChildByArg(candidateNodeKey(candidateName.getName())))
.isPresent();
}
private void searchForEntities(final EntityWalker walker) {
- Optional<NormalizedNode<?, ?>> possibleEntityTypes = getDataStore().readNode(ENTITY_TYPES_PATH);
+ Optional<NormalizedNode> possibleEntityTypes = getDataStore().readNode(ENTITY_TYPES_PATH);
if (!possibleEntityTypes.isPresent()) {
return;
}
- for (MapEntryNode entityType : ((MapNode) possibleEntityTypes.get()).getValue()) {
- Optional<DataContainerChild<?, ?>> possibleEntities = entityType.getChild(ENTITY_NODE_ID);
+ for (MapEntryNode entityType : ((MapNode) possibleEntityTypes.get()).body()) {
+ Optional<DataContainerChild> possibleEntities = entityType.findChildByArg(ENTITY_NODE_ID);
if (!possibleEntities.isPresent()) {
// shouldn't happen but handle anyway
continue;
}
- for (MapEntryNode entity: ((MapNode) possibleEntities.get()).getValue()) {
+ for (MapEntryNode entity: ((MapNode) possibleEntities.get()).body()) {
walker.onEntity(entityType, entity);
}
}
private String getCurrentOwner(final YangInstanceIdentifier entityId) {
return getDataStore().readNode(entityId.node(ENTITY_OWNER_QNAME))
- .map(owner -> owner.getValue().toString())
+ .map(owner -> owner.body().toString())
.orElse(null);
}
private final TrieMap<String, TrieMap<String, Long>> statistics = TrieMap.create();
- EntityOwnershipStatistics(){
+ EntityOwnershipStatistics() {
+ // Hidden on purpose
}
@Override
updateStatistics(entityType, newOwner, 1);
}
- Optional<NormalizedNode<?, ?>> dataBefore = changeRoot.getDataBefore();
+ Optional<NormalizedNode> dataBefore = changeRoot.getDataBefore();
if (dataBefore.isPresent()) {
String origOwner = extractOwner((LeafNode<?>) changeRoot.getDataBefore().get());
if (!Strings.isNullOrEmpty(origOwner)) {
*/
package org.opendaylight.controller.cluster.entityownership;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.argThat;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
import java.util.function.Function;
-import org.junit.Assert;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
import org.opendaylight.controller.cluster.datastore.AbstractActorTest;
import org.opendaylight.controller.cluster.datastore.AbstractShardTest;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
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.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
private static final AtomicInteger NEXT_SHARD_NUM = new AtomicInteger();
- protected void verifyEntityCandidate(final NormalizedNode<?, ?> node, final String entityType,
+ protected void verifyEntityCandidate(final NormalizedNode node, final String entityType,
final YangInstanceIdentifier entityId, final String candidateName, final boolean expectPresent) {
try {
assertNotNull("Missing " + EntityOwners.QNAME.toString(), node);
}
protected void verifyEntityCandidate(final String entityType, final YangInstanceIdentifier entityId,
- final String candidateName, final Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader,
+ final String candidateName, final Function<YangInstanceIdentifier,NormalizedNode> reader,
final boolean expectPresent) {
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
while (sw.elapsed(TimeUnit.MILLISECONDS) <= 5000) {
- NormalizedNode<?, ?> node = reader.apply(ENTITY_OWNERS_PATH);
+ NormalizedNode node = reader.apply(ENTITY_OWNERS_PATH);
try {
verifyEntityCandidate(node, entityType, entityId, candidateName, expectPresent);
return;
}
protected void verifyEntityCandidate(final String entityType, final YangInstanceIdentifier entityId,
- final String candidateName, final Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader) {
+ final String candidateName, final Function<YangInstanceIdentifier,NormalizedNode> reader) {
verifyEntityCandidate(entityType, entityId, candidateName, reader, true);
}
- protected MapEntryNode getMapEntryNodeChild(final DataContainerNode<? extends PathArgument> parent,
+ protected MapEntryNode getMapEntryNodeChild(final DataContainerNode parent,
final QName childMap, final QName child, final Object key, final boolean expectPresent) {
- Optional<DataContainerChild<? extends PathArgument, ?>> childNode =
- parent.getChild(new NodeIdentifier(childMap));
+ Optional<DataContainerChild> childNode = parent.findChildByArg(new NodeIdentifier(childMap));
// We have to account for empty maps disappearing. If we expect the entry to be non-present, tolerate a missing
// map.
if (!expectPresent && !childNode.isPresent()) {
assertTrue("Missing " + childMap.toString(), childNode.isPresent());
MapNode entityTypeMapNode = (MapNode) childNode.get();
- Optional<MapEntryNode> entityTypeEntry = entityTypeMapNode.getChild(NodeIdentifierWithPredicates.of(
+ Optional<MapEntryNode> entityTypeEntry = entityTypeMapNode.findChildByArg(NodeIdentifierWithPredicates.of(
childMap, child, key));
if (expectPresent && !entityTypeEntry.isPresent()) {
- fail("Missing " + childMap.toString() + " entry for " + key + ". Actual: " + entityTypeMapNode.getValue());
+ fail("Missing " + childMap.toString() + " entry for " + key + ". Actual: " + entityTypeMapNode.body());
} else if (!expectPresent && entityTypeEntry.isPresent()) {
fail("Found unexpected " + childMap.toString() + " entry for " + key);
}
}
static void verifyOwner(final String expected, final String entityType, final YangInstanceIdentifier entityId,
- final Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader) {
+ final Function<YangInstanceIdentifier,NormalizedNode> reader) {
AssertionError lastError = null;
YangInstanceIdentifier entityPath = entityPath(entityType, entityId).node(ENTITY_OWNER_QNAME);
Stopwatch sw = Stopwatch.createStarted();
while (sw.elapsed(TimeUnit.MILLISECONDS) <= 5000) {
try {
- NormalizedNode<?, ?> node = reader.apply(entityPath);
- Assert.assertNotNull("Owner was not set for entityId: " + entityId, node);
- Assert.assertEquals("Entity owner", expected, node.getValue().toString());
+ NormalizedNode node = reader.apply(entityPath);
+ assertNotNull("Owner was not set for entityId: " + entityId, node);
+ assertEquals("Entity owner", expected, node.body().toString());
return;
} catch (AssertionError e) {
lastError = e;
}
protected void verifyNodeRemoved(final YangInstanceIdentifier path,
- final Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader) {
+ final Function<YangInstanceIdentifier,NormalizedNode> reader) {
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
while (sw.elapsed(TimeUnit.MILLISECONDS) <= 5000) {
try {
- NormalizedNode<?, ?> node = reader.apply(path);
- Assert.assertNull("Node was not removed at path: " + path, node);
+ assertNull("Node was not removed at path: " + path, reader.apply(path));
return;
} catch (AssertionError e) {
lastError = e;
throw lastError;
}
- static void writeNode(final YangInstanceIdentifier path, final NormalizedNode<?, ?> node,
+ static void writeNode(final YangInstanceIdentifier path, final NormalizedNode node,
final ShardDataTree shardDataTree) throws DataValidationFailedException {
DataTreeModification modification = shardDataTree.newModification();
modification.merge(path, node);
final YangInstanceIdentifier entityId) {
YangInstanceIdentifier entityPath = entityPath(entityType, entityId).node(ENTITY_OWNER_QNAME);
try {
- NormalizedNode<?, ?> node = AbstractShardTest.readStore(shard, entityPath);
+ NormalizedNode node = AbstractShardTest.readStore(shard, entityPath);
if (node != null) {
- Assert.fail("Owner " + node.getValue() + " was set for " + entityPath);
+ fail("Owner " + node.body() + " was set for " + entityPath);
}
} catch (Exception e) {
ImmutableSet.copyOf(candidateRemoved.getRemainingCandidates()));
}
- private void writeNode(final YangInstanceIdentifier path, final NormalizedNode<?, ?> node)
+ private void writeNode(final YangInstanceIdentifier path, final NormalizedNode node)
throws DataValidationFailedException {
AbstractEntityOwnershipTest.writeNode(path, node, shardDataTree);
}
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
while (sw.elapsed(TimeUnit.MILLISECONDS) <= 10000) {
- Optional<NormalizedNode<?, ?>> possible = dataStore.newReadOnlyTransaction()
+ Optional<NormalizedNode> possible = dataStore.newReadOnlyTransaction()
.read(entityPath(entity.getType(), entity.getIdentifier()).node(Candidate.QNAME))
.get(5, TimeUnit.SECONDS);
try {
assertTrue("Candidates not found for " + entity, possible.isPresent());
Collection<String> actual = new ArrayList<>();
- for (MapEntryNode candidate: ((MapNode)possible.get()).getValue()) {
- actual.add(candidate.getChild(CANDIDATE_NAME_NODE_ID).get().getValue().toString());
+ for (MapEntryNode candidate: ((MapNode)possible.get()).body()) {
+ actual.add(candidate.findChildByArg(CANDIDATE_NAME_NODE_ID).get().body().toString());
}
assertEquals("Candidates for " + entity, Arrays.asList(expCandidates), actual);
anyBoolean(), anyBoolean());
}
- private void writeNode(final YangInstanceIdentifier path, final NormalizedNode<?, ?> node)
+ private void writeNode(final YangInstanceIdentifier path, final NormalizedNode node)
throws DataValidationFailedException {
AbstractEntityOwnershipTest.writeNode(path, node, shardDataTree);
}
assertEquals(val, statistics.get(ENTITY_TYPE).get(memberName).longValue());
}
- private void writeNode(final YangInstanceIdentifier path, final NormalizedNode<?, ?> node)
+ private void writeNode(final YangInstanceIdentifier path, final NormalizedNode node)
throws DataValidationFailedException {
AbstractEntityOwnershipTest.writeNode(path, node, shardDataTree);
}
@Override
public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc,
- final NormalizedNode<?, ?> input) {
+ final NormalizedNode input) {
return new RemoteDOMRpcFuture(rpc.getType(), ask(ExecuteRpc.from(rpc, input)));
}
/**
* An abstract base class for invocation requests. Specialized via {@link ExecuteAction} and {@link ExecuteRpc}.
*/
-public abstract class AbstractExecute<T, I extends NormalizedNode<?, ?>> implements Serializable {
+public abstract class AbstractExecute<T, I extends NormalizedNode> implements Serializable {
private static final long serialVersionUID = 1L;
private final transient @NonNull T type;
/**
* An abstract base class for invocation responses. Specialized via {@link ActionResponse} and {@link RpcResponse}.
*/
-public abstract class AbstractResponse<T extends NormalizedNode<?, ?>> implements Serializable {
+public abstract class AbstractResponse<T extends NormalizedNode> implements Serializable {
private static final long serialVersionUID = 1L;
private final transient @Nullable T output;
public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
@SuppressWarnings("unchecked")
final ImmutableList<RpcError> errors = (ImmutableList<RpcError>) in.readObject();
- final Optional<NormalizedNode<?, ?>> output = SerializationUtils.readNormalizedNode(in);
+ final Optional<NormalizedNode> output = SerializationUtils.readNormalizedNode(in);
actionResponse = new ActionResponse(output.map(ContainerNode.class::cast), errors);
}
import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataOutput;
import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeStreamVersion;
-public final class ExecuteRpc extends AbstractExecute<QName, @Nullable NormalizedNode<?, ?>> {
+public final class ExecuteRpc extends AbstractExecute<QName, @Nullable NormalizedNode> {
private static final long serialVersionUID = 1128904894827335676L;
- private ExecuteRpc(final @NonNull QName type, final @Nullable NormalizedNode<?, ?> input) {
+ private ExecuteRpc(final @NonNull QName type, final @Nullable NormalizedNode input) {
super(type, input);
}
public static @NonNull ExecuteRpc from(final @NonNull DOMRpcIdentifier rpc,
- final @Nullable NormalizedNode<?, ?> input) {
+ final @Nullable NormalizedNode input) {
return new ExecuteRpc(rpc.getType(), input);
}
public void readExternal(final ObjectInput in) throws IOException {
final NormalizedNodeDataInput stream = NormalizedNodeDataInput.newDataInput(in);
final QName type = stream.readQName();
- final NormalizedNode<?, ?> input = stream.readOptionalNormalizedNode().orElse(null);
+ final NormalizedNode input = stream.readOptionalNormalizedNode().orElse(null);
executeRpc = new ExecuteRpc(type, input);
}
import org.opendaylight.controller.cluster.datastore.node.utils.stream.SerializationUtils;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public class RpcResponse extends AbstractResponse<NormalizedNode<?, ?>> {
+public class RpcResponse extends AbstractResponse<NormalizedNode> {
private static final long serialVersionUID = -4211279498688989245L;
- public RpcResponse(final @Nullable NormalizedNode<?, ?> output) {
+ public RpcResponse(final @Nullable NormalizedNode output) {
super(output);
}
}
}
- static void assertCompositeNodeEquals(final NormalizedNode<? , ?> exp, final NormalizedNode<? , ?> actual) {
+ static void assertCompositeNodeEquals(final NormalizedNode exp, final NormalizedNode actual) {
assertEquals(exp, actual);
}
applicationTag, info, causeMsg);
}
- static void assertSuccessfulRpcResult(final DOMRpcResult rpcResult,
- final NormalizedNode<? , ?> expOutput) {
+ static void assertSuccessfulRpcResult(final DOMRpcResult rpcResult, final NormalizedNode expOutput) {
assertNotNull("RpcResult was null", rpcResult);
assertCompositeNodeEquals(expOutput, rpcResult.getResult());
}
final ContainerNode rpcOutput = makeRPCOutput("bar");
final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);
- final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
+ final NormalizedNode invokeRpcInput = makeRPCInput("foo");
@SuppressWarnings({"unchecked", "rawtypes"})
- final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
+ final ArgumentCaptor<NormalizedNode> inputCaptor =
ArgumentCaptor.forClass(NormalizedNode.class);
doReturn(FluentFutures.immediateFluentFuture(rpcResult)).when(domRpcService2)
public void testInvokeAction() throws Exception {
final ContainerNode actionOutput = makeRPCOutput("bar");
final DOMActionResult actionResult = new SimpleDOMActionResult(actionOutput, Collections.emptyList());
- final NormalizedNode<?, ?> invokeActionInput = makeRPCInput("foo");
+ final NormalizedNode invokeActionInput = makeRPCInput("foo");
@SuppressWarnings({"unchecked", "rawtypes"})
final ArgumentCaptor<ContainerNode> inputCaptor =
ArgumentCaptor.forClass(ContainerNode.class);
final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);
@SuppressWarnings({"unchecked", "rawtypes"})
- final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
+ final ArgumentCaptor<NormalizedNode> inputCaptor =
(ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
doReturn(FluentFutures.immediateFluentFuture(rpcResult)).when(domRpcService2)
final ContainerNode rpcOutput = null;
final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);
- final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
+ final NormalizedNode invokeRpcInput = makeRPCInput("foo");
@SuppressWarnings({"unchecked", "rawtypes"})
- final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
+ final ArgumentCaptor<NormalizedNode> inputCaptor =
(ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
doReturn(FluentFutures.immediateFluentFuture(rpcResult)).when(domRpcService2)
@SuppressWarnings({"checkstyle:AvoidHidingCauseException", "checkstyle:IllegalThrows"})
@Test(expected = DOMRpcException.class)
public void testInvokeRpcWithRemoteFailedFuture() throws Throwable {
- final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
+ final NormalizedNode invokeRpcInput = makeRPCInput("foo");
@SuppressWarnings({"unchecked", "rawtypes"})
- final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
+ final ArgumentCaptor<NormalizedNode> inputCaptor =
(ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
when(domRpcService2.invokeRpc(eq(TEST_RPC), inputCaptor.capture())).thenReturn(
@Ignore
@Test(expected = RemoteDOMRpcException.class)
public void testInvokeRpcWithAkkaTimeoutException() throws Exception {
- final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
+ final NormalizedNode invokeRpcInput = makeRPCInput("foo");
final ListenableFuture<DOMRpcResult> frontEndFuture = remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
@Test(expected = DOMRpcException.class)
@SuppressWarnings({"checkstyle:AvoidHidingCauseException", "checkstyle:IllegalThrows"})
public void testInvokeRpcWithLookupException() throws Throwable {
- final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
+ final NormalizedNode invokeRpcInput = makeRPCInput("foo");
doThrow(new RuntimeException("test")).when(domRpcService2).invokeRpc(any(QName.class),
any(NormalizedNode.class));
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.Uninterruptibles;
import com.typesafe.config.ConfigFactory;
-import java.net.URI;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
final int nRoutes = 500;
final Collection<DOMActionInstance> added = new ArrayList<>(nRoutes);
for (int i = 0; i < nRoutes; i++) {
- QName type = QName.create(URI.create("/mockaction"), "mockaction" + routeIdCounter++);
+ QName type = QName.create("/mockaction", "mockaction" + routeIdCounter++);
final DOMActionInstance routeId = DOMActionInstance.of(Absolute.of(type), LogicalDatastoreType.OPERATIONAL,
YangInstanceIdentifier.create(new YangInstanceIdentifier.NodeIdentifier(type)));
added.add(routeId);
}
private List<DOMActionInstance> createRouteIds() {
- QName type = QName.create(URI.create("/mockaction"), "mockaction" + routeIdCounter++);
+ QName type = QName.create("/mockaction", "mockaction" + routeIdCounter++);
List<DOMActionInstance> routeIds = new ArrayList<>(1);
routeIds.add(DOMActionInstance.of(Absolute.of(type), LogicalDatastoreType.OPERATIONAL,
YangInstanceIdentifier.create(new YangInstanceIdentifier.NodeIdentifier(type))));
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.Uninterruptibles;
import com.typesafe.config.ConfigFactory;
-import java.net.URI;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
final int nRoutes = 500;
final Collection<DOMRpcIdentifier> added = new ArrayList<>(nRoutes);
for (int i = 0; i < nRoutes; i++) {
- final DOMRpcIdentifier routeId = DOMRpcIdentifier.create(QName.create(URI.create("/mockrpc"), "type" + i));
+ final DOMRpcIdentifier routeId = DOMRpcIdentifier.create(QName.create("/mockrpc", "type" + i));
added.add(routeId);
//Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
}
private List<DOMRpcIdentifier> createRouteIds() {
- QName type = QName.create(URI.create("/mockrpc"), "mockrpc" + routeIdCounter++);
+ QName type = QName.create("/mockrpc", "mockrpc" + routeIdCounter++);
List<DOMRpcIdentifier> routeIds = new ArrayList<>(1);
routeIds.add(DOMRpcIdentifier.create(type));
return routeIds;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
private static final NodeIdentifier YEAR_NODE_ID = new NodeIdentifier(YEAR_QNAME);
@Override
- public FluentFuture<PostCanCommitStep> canCommit(Object txId, SchemaContext ctx,
- Collection<DOMDataTreeCandidate> candidates) {
+ public FluentFuture<PostCanCommitStep> canCommit(final Object txId, final SchemaContext ctx,
+ final Collection<DOMDataTreeCandidate> candidates) {
for (DOMDataTreeCandidate candidate : candidates) {
// Simple data validation - verify the year, if present, is >= 1990
final DataTreeCandidateNode rootNode = candidate.getRootNode();
- final Optional<NormalizedNode<?, ?>> dataAfter = rootNode.getDataAfter();
+ final Optional<NormalizedNode> dataAfter = rootNode.getDataAfter();
LOG.info("In canCommit: modificationType: {}, dataBefore: {}, dataAfter: {}",
rootNode.getModificationType(), rootNode.getDataBefore(), dataAfter);
// ModificationType because dataAfter will not be present. Also dataAfter *should* always contain a
// MapEntryNode but we verify anyway.
if (dataAfter.isPresent()) {
- final NormalizedNode<?, ?> normalizedNode = dataAfter.get();
+ final NormalizedNode normalizedNode = dataAfter.get();
Verify.verify(normalizedNode instanceof DataContainerNode,
"Expected type DataContainerNode, actual was %s", normalizedNode.getClass());
- DataContainerNode<?> entryNode = (DataContainerNode<?>) normalizedNode;
- final Optional<DataContainerChild<? extends PathArgument, ?>> possibleYear =
- entryNode.getChild(YEAR_NODE_ID);
+ DataContainerNode entryNode = (DataContainerNode) normalizedNode;
+ final Optional<DataContainerChild> possibleYear = entryNode.findChildByArg(YEAR_NODE_ID);
if (possibleYear.isPresent()) {
- final Number year = (Number) possibleYear.get().getValue();
+ final Number year = (Number) possibleYear.get().body();
LOG.info("year is {}", year);
- if (!(year.longValue() >= 1990)) {
+ if ((year.longValue() < 1990)) {
return FluentFutures.immediateFailedFluentFuture(new DataValidationFailedException(
DOMDataTreeIdentifier.class, candidate.getRootPath(),
String.format("Invalid year %d - year must be >= 1990", year)));
}
try (DOMDataTreeReadTransaction rTx = domDataBroker.newReadOnlyTransaction()) {
- final Optional<NormalizedNode<?, ?>> readResult = rTx.read(LogicalDatastoreType.CONFIGURATION,
+ final Optional<NormalizedNode> readResult = rTx.read(LogicalDatastoreType.CONFIGURATION,
WriteTransactionsHandler.ID_INT_YID).get();
if (!readResult.isPresent()) {
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import java.net.URI;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementationRegistration;
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.common.YangConstants;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
private static final Logger LOG = LoggerFactory.getLogger(GetConstantService.class);
private static final QNameModule MODULE = QNameModule.create(
- URI.create("tag:opendaylight.org,2017:controller:yang:lowlevel:target"), Revision.of("2017-02-15")).intern();
+ XMLNamespace.of("tag:opendaylight.org,2017:controller:yang:lowlevel:target"), Revision.of("2017-02-15"))
+ .intern();
private static final QName OUTPUT = YangConstants.operationOutputQName(MODULE).intern();
private static final QName CONSTANT = QName.create(MODULE, "constant").intern();
}
@Override
- public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
+ public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode input) {
LOG.debug("get-constant invoked, current value: {}", constant);
return Futures.immediateFuture(new DefaultDOMRpcResult(ImmutableContainerNodeBuilder.create()
private static final Logger LOG = LoggerFactory.getLogger(IdIntsListener.class);
private static final long SECOND_AS_NANO = 1000000000;
- private volatile NormalizedNode<?, ?> localCopy;
+ private volatile NormalizedNode localCopy;
private final AtomicLong lastNotifTimestamp = new AtomicLong(0);
private ScheduledExecutorService executorService;
private ScheduledFuture<?> scheduledFuture;
return localCopy != null;
}
- public boolean checkEqual(final NormalizedNode<?, ?> expected) {
+ public boolean checkEqual(final NormalizedNode expected) {
return localCopy.equals(expected);
}
@SuppressFBWarnings("BC_UNCONFIRMED_CAST")
- public String diffWithLocalCopy(final NormalizedNode<?, ?> expected) {
+ public String diffWithLocalCopy(final NormalizedNode expected) {
return diffNodes((MapNode)expected, (MapNode)localCopy);
}
final YangInstanceIdentifier.NodeIdentifier itemNodeId = new YangInstanceIdentifier.NodeIdentifier(ITEM);
Map<NodeIdentifierWithPredicates, MapEntryNode> expIdIntMap = new HashMap<>();
- expected.getValue().forEach(node -> expIdIntMap.put(node.getIdentifier(), node));
+ expected.body().forEach(node -> expIdIntMap.put(node.getIdentifier(), node));
- actual.getValue().forEach(actIdInt -> {
+ actual.body().forEach(actIdInt -> {
final MapEntryNode expIdInt = expIdIntMap.remove(actIdInt.getIdentifier());
if (expIdInt == null) {
builder.append('\n').append(" Unexpected id-int entry for ").append(actIdInt.getIdentifier());
}
Map<NodeIdentifierWithPredicates, MapEntryNode> expItemMap = new HashMap<>();
- ((MapNode)expIdInt.getChild(itemNodeId).get()).getValue()
+ ((MapNode)expIdInt.findChildByArg(itemNodeId).get()).body()
.forEach(node -> expItemMap.put(node.getIdentifier(), node));
- ((MapNode)actIdInt.getChild(itemNodeId).get()).getValue().forEach(actItem -> {
+ ((MapNode)actIdInt.findChildByArg(itemNodeId).get()).body().forEach(actItem -> {
final MapEntryNode expItem = expItemMap.remove(actItem.getIdentifier());
if (expItem == null) {
builder.append('\n').append(" Unexpected item entry ").append(actItem.getIdentifier())
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import java.net.URI;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
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.common.YangConstants;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
private static final Logger LOG = LoggerFactory.getLogger(RoutedGetConstantService.class);
private static final QNameModule MODULE = QNameModule.create(
- URI.create("tag:opendaylight.org,2017:controller:yang:lowlevel:target"), Revision.of("2017-02-15")).intern();
+ XMLNamespace.of("tag:opendaylight.org,2017:controller:yang:lowlevel:target"), Revision.of("2017-02-15"))
+ .intern();
private static final QName OUTPUT = YangConstants.operationOutputQName(MODULE).intern();
private static final QName CONSTANT = QName.create(MODULE, "constant").intern();
private static final QName GET_CONTEXTED_CONSTANT = QName.create(MODULE, "get-contexted-constant").intern();
}
@Override
- public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
+ public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode input) {
LOG.debug("get-contexted-constant invoked, current value: {}", constant);
return Futures.immediateFuture(new DefaultDOMRpcResult(ImmutableContainerNodeBuilder.create()
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import java.net.URI;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementationRegistration;
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.common.YangConstants;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
private static final Logger LOG = LoggerFactory.getLogger(SingletonGetConstantService.class);
private static final QNameModule MODULE = QNameModule.create(
- URI.create("tag:opendaylight.org,2017:controller:yang:lowlevel:target"), Revision.of("2017-02-15")).intern();
+ XMLNamespace.of("tag:opendaylight.org,2017:controller:yang:lowlevel:target"), Revision.of("2017-02-15"))
+ .intern();
private static final QName OUTPUT = YangConstants.operationOutputQName(MODULE).intern();
private static final QName CONSTANT = QName.create(MODULE, "constant").intern();
private static final QName CONTEXT = QName.create(MODULE, "context").intern();
}
@Override
- public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
+ public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode input) {
LOG.debug("get-singleton-constant invoked, current value: {}", constant);
return Futures.immediateFuture(new DefaultDOMRpcResult(ImmutableContainerNodeBuilder.create()
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.SystemMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOG.debug("Filling the item list with initial values.");
- final CollectionNodeBuilder<MapEntryNode, MapNode> mapBuilder = ImmutableNodes.mapNodeBuilder(ITEM);
+ final CollectionNodeBuilder<MapEntryNode, SystemMapNode> mapBuilder = ImmutableNodes.mapNodeBuilder(ITEM);
final YangInstanceIdentifier itemListId = idListItem.node(ITEM);
tx = domDataBroker.newWriteOnlyTransaction();
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>8.1.1</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
Code Review / controller.git / commitdiff