--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright © 2017 Red Hat, Inc. and others.
+ ~
+ ~ This program and the accompanying materials are made available under the
+ ~ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ ~ and is available at http://www.eclipse.org/legal/epl-v10.html
+ -->
+<features name="odl-controller-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.4.0">
+ <feature name="odl-config-netty-config-api" version="${project.version}">
+ <feature version="[3.0.0,4)">odl-netty-4</feature>
+ </feature>
+</features>
<!-- This needs to be added manually until we resolve the odl-mdsal-common situation -->
<repository>mvn:org.opendaylight.controller/odl-mdsal-common/${project.version}/xml/features</repository>
<feature name="odl-mdsal-broker-local" version="${project.version}">
+ <feature version="[3.0.0,4)">odl-lmax-3</feature>
<bundle start-level="70">mvn:org.opendaylight.controller/sal-schema-service/${project.version}</bundle>
<bundle start-level="40">mvn:org.opendaylight.controller/blueprint/${blueprint.version}</bundle>
<configfile finalname="${config.configfile.directory}/${config.mdsal.configfile}" override="true">
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright © 2017 Red Hat, Inc. and others.
+ ~
+ ~ This program and the accompanying materials are made available under the
+ ~ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ ~ and is available at http://www.eclipse.org/legal/epl-v10.html
+ -->
+<features name="odl-controller-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.4.0">
+ <feature name="odl-mdsal-clustering-commons" version="${project.version}">
+ <feature version="[3.0.0,4)">odl-akka-system-2.5</feature>
+ <feature version="[3.0.0,4)">odl-akka-persistence-2.5</feature>
+ <feature version="[3.0.0,4)">odl-akka-clustering-2.5</feature>
+ </feature>
+</features>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright © 2017 Red Hat, Inc. and others.
+ ~
+ ~ This program and the accompanying materials are made available under the
+ ~ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ ~ and is available at http://www.eclipse.org/legal/epl-v10.html
+ -->
+<features name="odl-controller-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.4.0">
+ <feature name="odl-mdsal-remoterpc-connector" version="${project.version}">
+ <feature version="[3.0.0,4)">odl-akka-leveldb-0.7</feature>
+ </feature>
+</features>
SchemaContext schemaContext = schemaService.getGlobalContext();
- Module module = schemaContext.findModuleByNamespaceAndRevision(bindingContext.bindingQName.getNamespace(),
- bindingContext.bindingQName.getRevision());
+ Module module = schemaContext.findModule(bindingContext.bindingQName.getModule()).orElse(null);
checkNotNull(module, "%s: Could not obtain the module schema for namespace %s, revision %s",
logName, bindingContext.bindingQName.getNamespace(), bindingContext.bindingQName.getRevision());
return (T) appConfig;
}
- private static void checkNotNull(Object reference, String errorMessageFormat, Object... formatArgs)
- throws ConfigXMLReaderException {
+ private static void checkNotNull(final Object reference, final String errorMessageFormat,
+ final Object... formatArgs) throws ConfigXMLReaderException {
checkCondition(reference != null, errorMessageFormat, formatArgs);
}
- private static void checkCondition(boolean expression, String errorMessageFormat, Object... formatArgs)
- throws ConfigXMLReaderException {
+ private static void checkCondition(final boolean expression, final String errorMessageFormat,
+ final Object... formatArgs) throws ConfigXMLReaderException {
if (!expression) {
throw new ConfigXMLReaderException(String.format(errorMessageFormat, formatArgs));
}
static Collection<SchemaPath> decomposeRpcService(final Class<RpcService> service,
final SchemaContext schemaContext, final Predicate<RpcRoutingStrategy> filter) {
final QNameModule moduleName = BindingReflections.getQNameModule(service);
- final Module module = schemaContext.findModuleByNamespaceAndRevision(moduleName.getNamespace(),
- moduleName.getRevision());
+ final Module module = schemaContext.findModule(moduleName).get();
LOG.debug("Resolved service {} to module {}", service, module);
final Collection<RpcDefinition> rpcs = module.getRpcs();
this.message = message;
}
- public void setStackTrace(final String stackTrace) {
- this.stackTrace = stackTrace;
+ public void setStackTrace(final String trace) {
+ this.stackTrace = trace;
}
@Override
import com.google.common.base.Optional;
import com.google.common.collect.Multimap;
-
import java.io.Closeable;
-import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import javax.management.InstanceNotFoundException;
import javax.management.ObjectName;
-
import org.opendaylight.controller.config.api.ConflictingVersionException;
import org.opendaylight.controller.config.api.ValidationException;
import org.opendaylight.controller.config.api.jmx.CommitStatus;
import org.opendaylight.controller.config.util.xml.XmlUtil;
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.slf4j.Logger;
setOnTransaction(ta, configExecution);
}
- private void setServicesOnTransaction(final ConfigTransactionClient ta, final ConfigExecution execution)
+ private static void setServicesOnTransaction(final ConfigTransactionClient ta, final ConfigExecution execution)
throws DocumentedException {
Services services = execution.getServices();
}
}
- private String getQname(final ConfigTransactionClient ta, final String namespace, final String serviceName) {
+ private static String getQname(final ConfigTransactionClient ta, final String namespace,
+ final String serviceName) {
return ta.getServiceInterfaceName(namespace, serviceName);
}
- private void setOnTransaction(final ConfigTransactionClient ta, final ConfigExecution execution)
+ private static void setOnTransaction(final ConfigTransactionClient ta, final ConfigExecution execution)
throws DocumentedException {
for (Multimap<String, ModuleElementResolved> modulesToResolved : execution.getResolvedXmlElements(ta)
}
}
- private void handleMisssingInstancesOnTransaction(final ConfigTransactionClient ta, final ConfigExecution execution)
- throws DocumentedException {
+ private static void handleMisssingInstancesOnTransaction(final ConfigTransactionClient ta,
+ final ConfigExecution execution) throws DocumentedException {
for (Multimap<String, ModuleElementDefinition> modulesToResolved : execution.getModulesDefinition(ta)
.values()) {
final YangStoreContext snapshot = yangStoreService.getCurrentSnapshot();
Map<String, Map<String, ModuleConfig>> factories = transformMbeToModuleConfigs(
snapshot.getModuleMXBeanEntryMap());
- Map<String, Map<Date, IdentityMapping>> identitiesMap = transformIdentities(snapshot.getModules());
+ Map<String, Map<Optional<Revision>, IdentityMapping>> identitiesMap =
+ transformIdentities(snapshot.getModules());
return new Config(factories, identitiesMap, snapshot.getEnumResolver());
}
- private static Map<String, Map<Date, IdentityMapping>> transformIdentities(final Set<Module> modules) {
- Map<String, Map<Date, IdentityMapping>> mappedIds = new HashMap<>();
+ private static Map<String, Map<Optional<Revision>, IdentityMapping>> transformIdentities(
+ final Set<Module> modules) {
+ Map<String, Map<Optional<Revision>, IdentityMapping>> mappedIds = new HashMap<>();
for (Module module : modules) {
String namespace = module.getNamespace().toString();
- Map<Date, IdentityMapping> revisionsByNamespace = mappedIds.computeIfAbsent(namespace,
+ Map<Optional<Revision>, IdentityMapping> revisionsByNamespace = mappedIds.computeIfAbsent(namespace,
k -> new HashMap<>());
- Date revision = module.getRevision();
+ Optional<Revision> revision = Optional.fromJavaUtil(module.getRevision());
IdentityMapping identityMapping = revisionsByNamespace.computeIfAbsent(revision,
k -> new IdentityMapping());
import org.opendaylight.controller.config.util.capability.Capability;
import org.opendaylight.controller.config.util.capability.YangModuleCapability;
import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
public class ConfigSubsystemFacadeFactory {
Set<Module> modules = yangStoreService.getModules();
final Set<Capability> capabilities = Sets.newHashSet();
for (Module module : modules) {
- capabilities.add(new YangModuleCapability(module, yangStoreService.getModuleSource(module)));
+ capabilities.add(new YangModuleCapability(module, yangStoreService.getModuleSource(
+ RevisionSourceIdentifier.create(module.getName(), module.getRevision()))));
}
return capabilities;
}
package org.opendaylight.controller.config.facade.xml.mapping.attributes.fromxml;
+import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
-import java.util.Date;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListDependenciesAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
+import org.opendaylight.yangtools.yang.common.Revision;
public class ObjectXmlReader extends AttributeIfcSwitchStatement<AttributeReadingStrategy> {
private String key;
- private Map<String, Map<Date, IdentityMapping>> identityMap;
+ private Map<String, Map<Optional<Revision>, IdentityMapping>> identityMap;
@SuppressWarnings("checkstyle:hiddenField")
public Map<String, AttributeReadingStrategy> prepareReading(final Map<String, AttributeIfc> yangToAttrConfig,
- final Map<String, Map<Date, IdentityMapping>> identityMap) {
+ final Map<String, Map<Optional<Revision>, IdentityMapping>> identityMap) {
Map<String, AttributeReadingStrategy> strategies = Maps.newHashMap();
this.identityMap = identityMap;
package org.opendaylight.controller.config.facade.xml.mapping.attributes.fromxml;
+import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import java.net.URI;
-import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.opendaylight.controller.config.facade.xml.mapping.IdentityMapping;
import org.opendaylight.controller.config.util.xml.DocumentedException;
import org.opendaylight.controller.config.util.xml.XmlElement;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
public class SimpleIdentityRefAttributeReadingStrategy extends SimpleAttributeReadingStrategy {
private final String key;
- private final Map<String, Map<Date, IdentityMapping>> identityMap;
+ private final Map<String, Map<Optional<Revision>, IdentityMapping>> identityMap;
public SimpleIdentityRefAttributeReadingStrategy(final String nullableDefault, final String key,
- final Map<String, Map<Date, IdentityMapping>> identityMap) {
+ final Map<String, Map<Optional<Revision>, IdentityMapping>> identityMap) {
super(nullableDefault);
this.key = key;
this.identityMap = identityMap;
namespace = namespaceOfTextContent.getValue();
}
- Date revision = null;
- Map<Date, IdentityMapping> revisions = identityMap.get(namespace);
+ Optional<Revision> revision = null;
+ Map<Optional<Revision>, IdentityMapping> revisions = identityMap.get(namespace);
if (revisions.keySet().size() > 1) {
- for (Map.Entry<Date, IdentityMapping> revisionToIdentityEntry : revisions.entrySet()) {
+ for (Map.Entry<Optional<Revision>, IdentityMapping> revisionToIdentityEntry : revisions.entrySet()) {
if (revisionToIdentityEntry.getValue().containsIdName(localName)) {
Preconditions.checkState(revision == null,
"Duplicate identity %s, in namespace %s, "
} else {
revision = revisions.keySet().iterator().next();
}
- return QName.create(URI.create(namespace), revision, localName).toString();
+ return QName.create(URI.create(namespace), revision.toJavaUtil(), localName).toString();
}
@Override
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
-import java.util.Date;
import java.util.Map;
import javax.management.openmbean.SimpleType;
-import org.opendaylight.controller.config.facade.xml.util.Util;
+import org.opendaylight.yangtools.yang.common.Revision;
public class SimpleAttributeMappingStrategy extends AbstractAttributeMappingStrategy<String, SimpleType<?>> {
static {
WRITER_PLUGINS.put(DEFAULT_WRITER_PLUGIN, new DefaultWriterPlugin());
- WRITER_PLUGINS.put(Date.class.getCanonicalName(), new DatePlugin());
+ WRITER_PLUGINS.put(Revision.class.getCanonicalName(), new RevisionPlugin());
}
/**
}
}
- static class DatePlugin implements WriterPlugin {
+ static class RevisionPlugin implements WriterPlugin {
@Override
public String writeObject(final Object value) {
- Preconditions.checkArgument(value instanceof Date, "Attribute must be Date");
- return Util.writeDate((Date) value);
+ Preconditions.checkArgument(value instanceof Revision, "Attribute must be Date");
+ return ((Revision) value).toString();
}
}
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.BigInteger;
-import java.text.ParseException;
+import java.time.format.DateTimeParseException;
import java.util.Date;
import java.util.Map;
import javax.management.openmbean.SimpleType;
import org.opendaylight.controller.config.facade.xml.util.Util;
import org.opendaylight.controller.config.util.xml.DocumentedException;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
protected Object parseObject(final Class<?> type, final String value) throws DocumentedException {
try {
- return Util.readDate(value);
- } catch (final ParseException e) {
+ return Revision.ofNullable(value).orElse(null);
+ } catch (final DateTimeParseException e) {
LOG.trace("Unable parse value {} due to ", value, e);
throw new DocumentedException("Unable to parse value " + value + " as date.", e,
DocumentedException.ErrorType.APPLICATION, DocumentedException.ErrorTag.OPERATION_FAILED,
import com.google.common.collect.Multimap;
import java.util.Collection;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.opendaylight.controller.config.util.xml.XmlElement;
import org.opendaylight.controller.config.util.xml.XmlMappingConstants;
import org.opendaylight.controller.config.util.xml.XmlUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
Map<String /* Name of module entry from yang file */,
ModuleConfig>> moduleConfigs;
- private final Map<String, Map<Date, IdentityMapping>> identityMap;
+ private final Map<String, Map<Optional<Revision>, IdentityMapping>> identityMap;
private final EnumResolver enumResolver;
public Config(final Map<String, Map<String, ModuleConfig>> moduleConfigs, final EnumResolver enumResolver) {
- this(moduleConfigs, Collections.<String, Map<Date, IdentityMapping>>emptyMap(), enumResolver);
+ this(moduleConfigs, Collections.<String, Map<Optional<Revision>, IdentityMapping>>emptyMap(), enumResolver);
}
public Config(final Map<String, Map<String, ModuleConfig>> moduleConfigs,
- final Map<String, Map<Date, IdentityMapping>> identityMap, final EnumResolver enumResolver) {
+ final Map<String, Map<Optional<Revision>, IdentityMapping>> identityMap, final EnumResolver enumResolver) {
this.moduleConfigs = moduleConfigs;
this.identityMap = identityMap;
this.enumResolver = enumResolver;
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
-
-import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-
import javax.management.ObjectName;
import javax.management.openmbean.OpenType;
-
import org.opendaylight.controller.config.facade.xml.mapping.IdentityMapping;
import org.opendaylight.controller.config.facade.xml.mapping.attributes.fromxml.AttributeConfigElement;
import org.opendaylight.controller.config.facade.xml.mapping.attributes.fromxml.AttributeReadingStrategy;
import org.opendaylight.controller.config.util.xml.XmlUtil;
import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
}
public InstanceConfigElementResolved fromXml(XmlElement moduleElement, final ServiceRegistryWrapper services,
- final String moduleNamespace, final EditStrategyType defaultStrategy,
- final Map<String, Map<Date, IdentityMapping>> identityMap,
- final EnumResolver enumResolver)
+ final String moduleNamespace, final EditStrategyType defaultStrategy,
+ final Map<String, Map<Optional<Revision>, IdentityMapping>> identityMap,
+ final EnumResolver enumResolver)
throws DocumentedException {
Map<String, AttributeConfigElement> retVal = Maps.newHashMap();
package org.opendaylight.controller.config.facade.xml.mapping.config;
import com.google.common.base.Optional;
-import java.util.Date;
import java.util.Map;
import javax.management.ObjectName;
import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
import org.opendaylight.controller.config.util.xml.XmlElement;
import org.opendaylight.controller.config.util.xml.XmlMappingConstants;
import org.opendaylight.controller.config.util.xml.XmlUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
public ModuleElementResolved fromXml(final XmlElement moduleElement, final ServiceRegistryWrapper depTracker,
final String instanceName, final String moduleNamespace, final EditStrategyType defaultStrategy,
- final Map<String, Map<Date, IdentityMapping>> identityMap, final EnumResolver enumResolver)
+ final Map<String, Map<Optional<Revision>, IdentityMapping>> identityMap, final EnumResolver enumResolver)
throws DocumentedException {
InstanceConfigElementResolved ice = instanceConfig.fromXml(moduleElement, depTracker, moduleNamespace,
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
public interface YangStoreContext {
*/
Set<Module> getModules();
- String getModuleSource(ModuleIdentifier moduleIdentifier);
+ String getModuleSource(SourceIdentifier moduleIdentifier);
EnumResolver getEnumResolver();
}
import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
+import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
}
@Override
- public String getModuleSource(final ModuleIdentifier moduleIdentifier) {
+ public String getModuleSource(final SourceIdentifier moduleIdentifier) {
return this.snap.getModuleSource(moduleIdentifier);
}
private static Set<Capability> toCapabilities(final Set<Module> modules, final YangStoreContext current) {
return ImmutableSet.copyOf(Collections2.transform(modules,
- input -> new YangModuleCapability(input, current.getModuleSource(input))));
+ input -> new YangModuleCapability(input, current.getModuleSource(
+ RevisionSourceIdentifier.create(input.getName(), input.getRevision())))));
}
}
package org.opendaylight.controller.config.facade.xml.osgi;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.BiMap;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.common.io.ByteStreams;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.PackageTranslator;
import org.opendaylight.controller.config.yangjmxgenerator.ServiceInterfaceEntry;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
+import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
}
@Override
- public String getModuleSource(final org.opendaylight.yangtools.yang.model.api.ModuleIdentifier moduleIdentifier) {
- final CheckedFuture<? extends YangTextSchemaSource, SchemaSourceException> source = this.sourceProvider
- .getSource(SourceIdentifier.create(moduleIdentifier.getName(),
- Optional.fromNullable(QName.formattedRevision(moduleIdentifier.getRevision()))));
-
+ public String getModuleSource(final SourceIdentifier moduleIdentifier) {
+ final ListenableFuture<? extends YangTextSchemaSource> source = this.sourceProvider.getSource(
+ RevisionSourceIdentifier.create(moduleIdentifier.getName(), moduleIdentifier.getRevision()));
try {
- final YangTextSchemaSource yangTextSchemaSource = source.checkedGet();
+ final YangTextSchemaSource yangTextSchemaSource = source.get();
try (InputStream inStream = yangTextSchemaSource.openStream()) {
return new String(ByteStreams.toByteArray(inStream), StandardCharsets.UTF_8);
}
- } catch (SchemaSourceException | IOException e) {
+ } catch (ExecutionException | InterruptedException | IOException e) {
LOG.warn("Unable to provide source for {}", moduleIdentifier, e);
throw new IllegalArgumentException("Unable to provide source for " + moduleIdentifier, e);
}
package org.opendaylight.controller.config.facade.xml.rpc;
+import com.google.common.base.Optional;
import com.google.common.collect.Maps;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry.Rpc;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
+import org.opendaylight.yangtools.yang.common.Revision;
public final class InstanceRuntimeRpc {
// FIXME add identity map to runtime data
Map<String, AttributeReadingStrategy> strats = new ObjectXmlReader().prepareReading(yangToAttrConfig,
- Collections.<String, Map<Date, IdentityMapping>>emptyMap());
+ Collections.<String, Map<Optional<Revision>, IdentityMapping>>emptyMap());
for (Entry<String, AttributeReadingStrategy> readStratEntry : strats.entrySet()) {
List<XmlElement> configNodes = configRootNode.getChildElements(readStratEntry.getKey());
package org.opendaylight.controller.config.facade.xml.util;
-import static org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil.getRevisionFormat;
-
import com.google.common.base.Preconditions;
-import java.text.ParseException;
-import java.util.Date;
public final class Util {
private Util() {
}
- public static String writeDate(final Date date) {
- return getRevisionFormat().format(date);
- }
-
- public static Date readDate(final String string) throws ParseException {
- return getRevisionFormat().parse(string);
- }
-
public static void checkType(final Object value, final Class<?> clazz) {
Preconditions.checkArgument(clazz.isAssignableFrom(value.getClass()),
"Unexpected type " + value.getClass() + " should be " + clazz + " of " + value);
import static org.junit.Assert.assertEquals;
+import com.google.common.base.Optional;
import com.google.common.collect.Maps;
import java.net.URI;
import java.util.Collections;
-import java.util.Date;
import java.util.Map;
import org.junit.Test;
import org.opendaylight.controller.config.facade.xml.mapping.IdentityMapping;
import org.opendaylight.controller.config.util.xml.XmlElement;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
public class SimpleIdentityRefAttributeReadingStrategyTest {
@Test
public void testReadIdRef() throws Exception {
- final Map<String, Map<Date, IdentityMapping>> identityMapping = Maps.newHashMap();
+ final Map<String, Map<Optional<Revision>, IdentityMapping>> identityMapping = Maps.newHashMap();
final IdentityMapping value = new IdentityMapping();
- final Date rev = new Date();
+ final Optional<Revision> rev = Optional.of(Revision.of("2017-10-10"));
identityMapping.put("namespace", Collections.singletonMap(rev, value));
identityMapping.put("inner", Collections.singletonMap(rev, value));
final SimpleIdentityRefAttributeReadingStrategy key = new SimpleIdentityRefAttributeReadingStrategy(null, "key",
identityMapping);
String read = key.readElementContent(XmlElement.fromString("<el xmlns=\"namespace\">local</el>"));
- assertEquals(
- org.opendaylight.yangtools.yang.common.QName.create(URI.create("namespace"), rev, "local").toString(),
- read);
+ assertEquals(QName.create(URI.create("namespace"), rev.toJavaUtil(), "local").toString(), read);
read = key.readElementContent(XmlElement.fromString("<el xmlns:a=\"inner\" xmlns=\"namespace\">a:local</el>"));
- assertEquals(org.opendaylight.yangtools.yang.common.QName.create(URI.create("inner"), rev, "local").toString(),
- read);
+ assertEquals(QName.create(URI.create("inner"), rev.toJavaUtil(), "local").toString(), read);
read = key.readElementContent(
- XmlElement.fromString("<top xmlns=\"namespace\"><el>local</el></top>").getOnlyChildElement());
- assertEquals(
- org.opendaylight.yangtools.yang.common.QName.create(URI.create("namespace"), rev, "local").toString(),
- read);
+ XmlElement.fromString("<top xmlns=\"namespace\"><el>local</el></top>").getOnlyChildElement());
+ assertEquals(QName.create(URI.create("namespace"), rev.toJavaUtil(), "local").toString(), read);
}
}
}
@Override
- public void close() throws Exception {
+ public void close() {
this.inner.close();
// send modify event when a bundle disappears
updateService();
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+
import com.google.common.base.Throwables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.util.ConfigRegistryClient;
import org.opendaylight.controller.config.util.capability.Capability;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.w3c.dom.Element;
public class ConfigPusherImplTest {
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
- doReturn("content").when(yangStoreService).getModuleSource(any(ModuleIdentifier.class));
+ doReturn("content").when(yangStoreService).getModuleSource(any(SourceIdentifier.class));
doReturn("mocked snapshot").when(mockedConfigSnapshot).toString();
doReturn("<mocked-snapshot/>").when(mockedConfigSnapshot).getConfigSnapshot();
doReturn(Collections.<Module>emptySet()).when(yangStoreService).getModules();
package org.opendaylight.controller.config.util.capability;
import com.google.common.base.Optional;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.Module;
/**
this.content = moduleContent;
this.moduleName = module.getName();
this.moduleNamespace = module.getNamespace().toString();
- this.revision = SimpleDateFormatUtil.getRevisionFormat().format(module.getRevision());
+ this.revision = module.getRevision().map(Revision::toString).orElse(null);
}
@Override
}
private static String toCapabilityURI(final Module module) {
- return String.valueOf(module.getNamespace()) + "?module="
- + module.getName() + "&revision=" + SimpleDateFormatUtil.getRevisionFormat().format(module.getRevision());
+ final StringBuilder sb = new StringBuilder();
+ sb.append(module.getNamespace()).append("?module=").append(module.getName());
+
+ final java.util.Optional<Revision> rev = module.getRevision();
+ if (rev.isPresent()) {
+ sb.append("&revision=").append(rev.get());
+ }
+ return sb.toString();
}
@Override
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
import com.google.common.io.Files;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
+import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.maven.project.MavenProject;
}
@Override
- public Collection<File> generateSources(final SchemaContext context,
- final File outputBaseDir, final Set<Module> yangModulesInCurrentMavenModule) {
+ public Collection<File> generateSources(final SchemaContext context, final File outputBaseDir,
+ final Set<Module> currentModules, final Function<Module, Optional<String>> moduleResourcePathResolver) {
Preconditions.checkArgument(context != null, "Null context received");
Preconditions.checkArgument(outputBaseDir != null,
"Null outputBaseDir received");
Preconditions
- .checkArgument((this.namespaceToPackageMapping != null) && !this.namespaceToPackageMapping.isEmpty(),
+ .checkArgument(this.namespaceToPackageMapping != null && !this.namespaceToPackageMapping.isEmpty(),
"No namespace to package mapping provided in additionalConfiguration");
final PackageTranslator packageTranslator = new PackageTranslator(this.namespaceToPackageMapping);
+ sieEntry.getValue());
}
}
- if (yangModulesInCurrentMavenModule.contains(module)) {
+ if (currentModules.contains(module)) {
// write this sie to disk
for (final ServiceInterfaceEntry sie : namesToSIEntries.values()) {
try {
final StringBuilder fullyQualifiedNamesOfFactories = new StringBuilder();
// create MBEs
- for (final Module module : yangModulesInCurrentMavenModule) {
+ for (final Module module : currentModules) {
final String packageName = packageTranslator.getPackageName(module);
final Map<String /* MB identity local name */, ModuleMXBeanEntry> namesToMBEs = ModuleMXBeanEntry
.create(module, qNamesToSIEs, context, new TypeProviderWrapper(new TypeProviderImpl(context)),
}
}
// create ModuleFactory file if needed
- if ((fullyQualifiedNamesOfFactories.length() > 0)
+ if (fullyQualifiedNamesOfFactories.length() > 0
&& this.generateModuleFactoryFile) {
final File serviceLoaderFile = JMXGenerator.concatFolders(
this.resourceBaseDir, "META-INF", "services",
serviceLoaderFile.getParentFile().mkdirs();
try {
serviceLoaderFile.createNewFile();
- Files.write(fullyQualifiedNamesOfFactories.toString(), serviceLoaderFile, StandardCharsets.UTF_8);
+ Files.asCharSink(serviceLoaderFile, StandardCharsets.UTF_8).write(
+ fullyQualifiedNamesOfFactories.toString());
} catch (final IOException e) {
final String message = "Cannot write to " + serviceLoaderFile;
LOG.error(message, e);
private static Map<String, String> extractNamespaceMapping(
final Map<String, String> additionalCfg) {
- final Map<String, String> namespaceToPackage = Maps.newHashMap();
+ final Map<String, String> namespaceToPackage = new HashMap<>();
for (final String key : additionalCfg.keySet()) {
if (key.startsWith(NAMESPACE_TO_PACKAGE_PREFIX)) {
final String mapping = additionalCfg.get(key);
@VisibleForTesting
static class GeneratedFilesTracker {
- private final Set<File> files = Sets.newHashSet();
+ private final Set<File> files = new HashSet<>();
void addFile(final File file) {
if (this.files.contains(file)) {
- final List<File> undeletedFiles = Lists.newArrayList();
+ final List<File> undeletedFiles = new ArrayList<>();
for (final File presentFile : this.files) {
if (!presentFile.delete()) {
undeletedFiles.add(presentFile);
}
}
if (!undeletedFiles.isEmpty()) {
- LOG.error(
- "Illegal state occurred: Unable to delete already generated files, undeleted files: {}",
+ LOG.error("Illegal state occurred: Unable to delete already generated files, undeleted files: {}",
undeletedFiles);
}
- throw new IllegalStateException(
- "Name conflict in generated files, file" + file
- + " present twice");
+ throw new IllegalStateException("Name conflict in generated files, file" + file + " present twice");
}
this.files.add(file);
}
import org.opendaylight.controller.config.yangjmxgenerator.ServiceInterfaceEntry;
import org.opendaylight.yangtools.yang.binding.annotations.ModuleQName;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
public class Annotation {
final String name;
final List<Parameter> params;
- public Annotation(
String name, List<Parameter> params) {
+ public Annotation(
final String name, final List<Parameter> params) {
this.name = name;
this.params = params;
}
return params;
}
- public static Annotation createFromMap(Class<?> annotationClass, Map<String, String> parameters) {
+ public static Annotation createFromMap(final Class<?> annotationClass, final Map<String, String> parameters) {
List<Parameter> parameterList = new ArrayList<>();
for(Entry<String, String> entry: parameters.entrySet()) {
parameterList.add(new Parameter(entry.getKey(), entry.getValue()));
return new Annotation(annotationClass.getCanonicalName(), parameterList);
}
- public static Annotation createDescriptionAnnotation(String description) {
+ public static Annotation createDescriptionAnnotation(final String description) {
Preconditions.checkNotNull(description,
"Cannot create annotation from null description");
return new Annotation(Description.class.getCanonicalName(),
Lists.newArrayList(new Parameter("value", q(description))));
}
- public static Annotation createModuleQNameANnotation(QName qName) {
+ public static Annotation createModuleQNameANnotation(final QName qName) {
Map<String, String> parameters = new HashMap<>();
parameters.put("namespace", q(qName.getNamespace().toString()));
- parameters.put("revision", q(qName.getFormattedRevision()));
+ parameters.put("revision", q(qName.getRevision().map(Revision::toString).orElse(null)));
parameters.put("name", q(qName.getLocalName()));
return Annotation.createFromMap(ModuleQName.class, parameters);
}
- public static Collection<Annotation> createSieAnnotations(ServiceInterfaceEntry sie){
+ public static Collection<Annotation> createSieAnnotations(final ServiceInterfaceEntry sie){
String exportedClassName = sie.getExportedOsgiClassName();
Preconditions.checkNotNull(sie.getQName(),
params.add(new Parameter("osgiRegistrationType", exportedClassName + ".class"));
params.add(new Parameter("registerToOsgi", Boolean.toString(sie.isRegisterToOsgi())));
params.add(new Parameter("namespace", q(sie.getQName().getNamespace().toString())));
- params.add(new Parameter("revision", q(sie.getQName().getFormattedRevision())));
+ params.add(new Parameter("revision", q(sie.getQName().getRevision().map(Revision::toString).orElse(null))));
params.add(new Parameter("localName", q(sie.getQName().getLocalName())));
Annotation sieAnnotation = new Annotation(ServiceInterfaceAnnotation.class.getCanonicalName(), params);
{
List<Parameter> params = new ArrayList<>();
params.add(new Parameter("namespace", q(sie.getYangModuleQName().getNamespace().toString())));
- params.add(new Parameter("revision", q(sie.getYangModuleQName().getFormattedRevision())));
+ params.add(new Parameter("revision", q(sie.getYangModuleQName().getRevision()
+ .map(Revision::toString).orElse(null))));
params.add(new Parameter("name", q(sie.getYangModuleQName().getLocalName())));
Annotation moduleQNameAnnotation = new Annotation(ModuleQName.class.getCanonicalName(), params);
}
public static Annotation createRequireIfcAnnotation(
- ServiceInterfaceEntry sie) {
+ final ServiceInterfaceEntry sie) {
String reqIfc = sie.getFullyQualifiedName() + ".class";
return new Annotation(RequireInterface.class.getCanonicalName(),
Lists.newArrayList(new Parameter("value", reqIfc)));
private static final String quote = "\"";
- public static String q(String nullableDescription) {
- return nullableDescription == null ? null : quote + nullableDescription
- + quote;
+ public static String q(final String nullableDescription) {
+ return nullableDescription == null ? null : quote + nullableDescription + quote;
}
public static class Parameter {
private final String key, value;
- public Parameter(String key, String value) {
+ public Parameter(final String key, final String value) {
this.key = key;
this.value = value;
}
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import com.google.common.collect.Sets;
+import com.google.common.collect.ImmutableSet;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.controller.config.yangjmxgenerator.ConfigConstants;
import org.opendaylight.controller.config.yangjmxgenerator.PackageTranslatorTest;
map.put(JMXGenerator.MODULE_FACTORY_FILE_BOOLEAN, "randomValue");
jmxGenerator.setAdditionalConfig(map);
try {
- jmxGenerator.generateSources(context, outputBaseDir,
- Sets.newHashSet(testFilesModule, testFiles1Module));
+ jmxGenerator.generateSources(context, outputBaseDir, ImmutableSet.of(testFilesModule, testFiles1Module),
+ m -> Optional.empty());
fail();
} catch (RuntimeException e) {
final Throwable cause = e.getCause();
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.opendaylight.controller.config.yangjmxgenerator.PackageTranslatorTest.EXPECTED_PACKAGE_PREFIX;
+
import com.github.javaparser.JavaParser;
import com.github.javaparser.ParseException;
import com.github.javaparser.ast.CompilationUnit;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
@Test
public void generateSIsMBsTest() {
- Collection<File> files = jmxGenerator.generateSources(context,
- outputBaseDir, context.getModules());
+ Collection<File> files = jmxGenerator.generateSources(context, outputBaseDir, context.getModules(),
+ m -> Optional.empty());
List<String> expectedFileNames = new ArrayList<>();
expectedFileNames
.addAll(ServiceInterfaceEntryTest.expectedSIEFileNames);
@Test
public void generateSIEsTest() throws IOException, ParseException {
- Collection<File> files = jmxGenerator.generateSources(context,
- outputBaseDir, Collections.singleton(threadsModule));
+ Collection<File> files = jmxGenerator.generateSources(context, outputBaseDir,
+ Collections.singleton(threadsModule), m -> Optional.empty());
assertEquals(ServiceInterfaceEntryTest.expectedSIEFileNames, toFileNames(files));
for (File file : files) {
jmxGenerator.setAdditionalConfig(map);
Collection<File> files = jmxGenerator.generateSources(context, outputBaseDir,
- Collections.singleton(bgpListenerJavaModule));
+ Collections.singleton(bgpListenerJavaModule), m -> Optional.empty());
assertEquals(expectedGenerateMBEsListNames, toFileNames(files));
}
jmxGenerator.setAdditionalConfig(map);
Collection<File> files = jmxGenerator.generateSources(context, outputBaseDir,
- Collections.singleton(threadsJavaModule));
+ Collections.singleton(threadsJavaModule), m -> Optional.empty());
assertEquals(expectedModuleFileNames, toFileNames(files));
private Collection<RuntimeBeanEntry> runtimeBeans;
private String nullableDummyContainerName;
- ModuleMXBeanEntry(ModuleMXBeanEntryInitial initials, Map<String, AttributeIfc> yangToAttributes,
- Map<String, QName> providedServices2, Collection<RuntimeBeanEntry> runtimeBeans) {
+ ModuleMXBeanEntry(final ModuleMXBeanEntryInitial initials, final Map<String, AttributeIfc> yangToAttributes,
+ final Map<String, QName> providedServices2, final Collection<RuntimeBeanEntry> runtimeBeans) {
this.yangToAttributes = yangToAttributes;
this.providedServices = Collections.unmodifiableMap(providedServices2);
this.runtimeBeans = runtimeBeans;
return ABSTRACT_PREFIX + getStubModuleName();
}
- public String getFullyQualifiedName(String typeName) {
+ public String getFullyQualifiedName(final String typeName) {
return FullyQualifiedNameHelper.getFullyQualifiedName(initial.packageName,
typeName);
}
return providedServices;
}
- public void setRuntimeBeans(Collection<RuntimeBeanEntry> newRuntimeBeans) {
+ public void setRuntimeBeans(final Collection<RuntimeBeanEntry> newRuntimeBeans) {
runtimeBeans = newRuntimeBeans;
}
* instances as values
*/
public static Map<String/* identity local name */, ModuleMXBeanEntry> create(
- Module currentModule,
- Map<QName, ServiceInterfaceEntry> qNamesToSIEs,
- SchemaContext schemaContext,
- TypeProviderWrapper typeProviderWrapper, String packageName) {
+ final Module currentModule,
+ final Map<QName, ServiceInterfaceEntry> qNamesToSIEs,
+ final SchemaContext schemaContext,
+ final TypeProviderWrapper typeProviderWrapper, final String packageName) {
ModuleMXBeanEntryBuilder builder = new ModuleMXBeanEntryBuilder().setModule(currentModule).setqNamesToSIEs(qNamesToSIEs)
.setSchemaContext(schemaContext).setTypeProviderWrapper(typeProviderWrapper)
return yangToAttributes;
}
- void setYangToAttributes(Map<String, AttributeIfc> newAttributes) {
+ void setYangToAttributes(final Map<String, AttributeIfc> newAttributes) {
this.yangToAttributes = newAttributes;
}
return nullableDummyContainerName;
}
- public void setNullableDummyContainerName(String nullableDummyContainerName) {
+ public void setNullableDummyContainerName(final String nullableDummyContainerName) {
this.nullableDummyContainerName = nullableDummyContainerName;
}
static final class ModuleMXBeanEntryInitial {
- private String localName;
- private String description;
- private String packageName;
- private String javaNamePrefix;
- private String namespace;
- private QName qName;
+ private final String localName;
+ private final String description;
+ private final String packageName;
+ private final String javaNamePrefix;
+ private final String namespace;
+ private final QName qName;
- ModuleMXBeanEntryInitial(String localName, String description, String packageName, String javaNamePrefix, String namespace, QName qName) {
+ ModuleMXBeanEntryInitial(final String localName, final String description, final String packageName, final String javaNamePrefix, final String namespace, final QName qName) {
this.localName = localName;
this.description = description;
this.packageName = packageName;
private String namespace;
private QName qName;
- public ModuleMXBeanEntryInitialBuilder setPackageName(String packageName) {
+ public ModuleMXBeanEntryInitialBuilder setPackageName(final String packageName) {
this.packageName = packageName;
return this;
}
- public ModuleMXBeanEntryInitialBuilder setJavaNamePrefix(String javaNamePrefix) {
+ public ModuleMXBeanEntryInitialBuilder setJavaNamePrefix(final String javaNamePrefix) {
this.javaNamePrefix = javaNamePrefix;
return this;
}
- public ModuleMXBeanEntryInitialBuilder setNamespace(String namespace) {
+ public ModuleMXBeanEntryInitialBuilder setNamespace(final String namespace) {
this.namespace = namespace;
return this;
}
- public ModuleMXBeanEntryInitialBuilder setqName(QName qName) {
+ public ModuleMXBeanEntryInitialBuilder setqName(final QName qName) {
this.qName = qName;
return this;
}
return new ModuleMXBeanEntry.ModuleMXBeanEntryInitial(localName, description, packageName, javaNamePrefix, namespace, qName);
}
- public ModuleMXBeanEntryInitialBuilder setIdSchemaNode(IdentitySchemaNode idSchemaNode) {
+ public ModuleMXBeanEntryInitialBuilder setIdSchemaNode(final IdentitySchemaNode idSchemaNode) {
this.localName = idSchemaNode.getQName().getLocalName();
- this.description = idSchemaNode.getDescription();
+ this.description = idSchemaNode.getDescription().orElse(null);
return this;
}
import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.NameConflictException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.rev130405.ServiceRef;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
Map<String, ModuleMXBeanEntry> result = new HashMap<>();
- for (AugmentationSchema augmentation : currentModule.getAugmentations()) {
+ for (AugmentationSchemaNode augmentation : currentModule.getAugmentations()) {
Collection<DataSchemaNode> childNodes = augmentation.getChildNodes();
- if (areAllChildrenChoiceCaseNodes(childNodes)) {
- for (ChoiceCaseNode childCase : castChildNodesToChoiceCases(childNodes)) {
+ if (areAllChildrenCaseSchemaNodes(childNodes)) {
+ for (CaseSchemaNode childCase : castChildNodesToChoiceCases(childNodes)) {
// TODO refactor, extract to standalone builder class
- processChoiceCaseNode(result, uniqueGeneratedClassesNames, configModulePrefix, moduleIdentities,
+ processCaseSchemaNode(result, uniqueGeneratedClassesNames, configModulePrefix, moduleIdentities,
unaugmentedModuleIdentities, augmentation, childCase);
}
} // skip if child nodes are not all cases
}
}
- private static void checkAttributeNamesUniqueness(final Map<String, QName> uniqueGeneratedClassesNames, final Map<String, ModuleMXBeanEntry> result) {
+ private static void checkAttributeNamesUniqueness(final Map<String, QName> uniqueGeneratedClassesNames,
+ final Map<String, ModuleMXBeanEntry> result) {
for (Map.Entry<String, ModuleMXBeanEntry> entry : result.entrySet()) {
checkUniqueRuntimeBeanAttributesName(entry.getValue(),
uniqueGeneratedClassesNames);
Map<String, IdentitySchemaNode> moduleIdentities = Maps.newHashMap();
for (IdentitySchemaNode id : currentModule.getIdentities()) {
- if (id.getBaseIdentity() != null
- && ConfigConstants.MODULE_TYPE_Q_NAME.equals(id.getBaseIdentity().getQName())) {
+ if (!id.getBaseIdentities().isEmpty()
+ && ConfigConstants.MODULE_TYPE_Q_NAME.equals(id.getBaseIdentities().iterator().next().getQName())) {
String identityLocalName = id.getQName().getLocalName();
if (moduleIdentities.containsKey(identityLocalName)) {
throw new IllegalStateException("Module name already defined in this currentModule: "
return moduleIdentities;
}
- private static Collection<ChoiceCaseNode> castChildNodesToChoiceCases(final Collection<DataSchemaNode> childNodes) {
- return Collections2.transform(childNodes, new Function<DataSchemaNode, ChoiceCaseNode>() {
+ private static Collection<CaseSchemaNode> castChildNodesToChoiceCases(final Collection<DataSchemaNode> childNodes) {
+ return Collections2.transform(childNodes, new Function<DataSchemaNode, CaseSchemaNode>() {
@Nullable
@Override
- public ChoiceCaseNode apply(@Nullable final DataSchemaNode input) {
- return (ChoiceCaseNode) input;
+ public CaseSchemaNode apply(@Nullable final DataSchemaNode input) {
+ return (CaseSchemaNode) input;
}
});
}
- private static boolean areAllChildrenChoiceCaseNodes(final Iterable<DataSchemaNode> childNodes) {
+ private static boolean areAllChildrenCaseSchemaNodes(final Iterable<DataSchemaNode> childNodes) {
for (DataSchemaNode childNode : childNodes) {
- if (childNode instanceof ChoiceCaseNode == false) {
+ if (childNode instanceof CaseSchemaNode == false) {
return false;
}
}
return true;
}
- private <HAS_CHILDREN_AND_QNAME extends DataNodeContainer & SchemaNode> void processChoiceCaseNode(final Map<String, ModuleMXBeanEntry> result,
+ private <HAS_CHILDREN_AND_QNAME extends DataNodeContainer & SchemaNode> void processCaseSchemaNode(
+ final Map<String, ModuleMXBeanEntry> result,
final Map<String, QName> uniqueGeneratedClassesNames, final String configModulePrefix,
final Map<String, IdentitySchemaNode> moduleIdentities,
- final Map<String, IdentitySchemaNode> unaugmentedModuleIdentities, final AugmentationSchema augmentation,
- final DataSchemaNode when) {
+ final Map<String, IdentitySchemaNode> unaugmentedModuleIdentities,
+ final AugmentationSchemaNode augmentation, final DataSchemaNode when) {
- ChoiceCaseNode choiceCaseNode = (ChoiceCaseNode) when;
- if (choiceCaseNode.getConstraints() == null || choiceCaseNode.getConstraints().getWhenCondition() == null) {
+ CaseSchemaNode choiceCaseNode = (CaseSchemaNode) when;
+ if (!choiceCaseNode.getWhenCondition().isPresent()) {
return;
}
- RevisionAwareXPath xPath = choiceCaseNode.getConstraints().getWhenCondition();
- Matcher matcher = getWhenConditionMatcher(configModulePrefix, xPath);
+ java.util.Optional<RevisionAwareXPath> xPath = choiceCaseNode.getWhenCondition();
+ checkState(xPath.isPresent(), "Choice node %s does not have a when condition", choiceCaseNode);
+ Matcher matcher = getWhenConditionMatcher(configModulePrefix, xPath.get());
if (matcher.matches() == false) {
return;
}
* @param choiceCaseNode state or configuration case statement
* @return either choiceCaseNode or its only child container
*/
- private static <HAS_CHILDREN_AND_QNAME extends DataNodeContainer & SchemaNode> HAS_CHILDREN_AND_QNAME getDataNodeContainer(final ChoiceCaseNode choiceCaseNode) {
+ private static <HAS_CHILDREN_AND_QNAME extends DataNodeContainer & SchemaNode> HAS_CHILDREN_AND_QNAME getDataNodeContainer(final CaseSchemaNode choiceCaseNode) {
Collection<DataSchemaNode> childNodes = choiceCaseNode.getChildNodes();
if (childNodes.size() == 1) {
DataSchemaNode onlyChild = childNodes.iterator().next();
qNamesToSIEs, schemaContext);
LeafSchemaNode refine = (LeafSchemaNode) usesNode.getRefines().values().iterator().next();
- boolean mandatory = refine.getConstraints().isMandatory();
+ boolean mandatory = refine.isMandatory();
AbstractDependencyAttribute reference;
if (dataNodeContainer instanceof ContainerSchemaNode) {
reference = new DependencyAttribute(attrNode, serviceInterfaceEntry, mandatory,
- attrNode.getDescription());
+ attrNode.getDescription().orElse(null));
} else {
reference = new ListDependenciesAttribute(attrNode, serviceInterfaceEntry, mandatory,
- attrNode.getDescription());
+ attrNode.getDescription().orElse(null));
}
return Optional.of(reference);
}
// Module from SchemaContext
String prefix = m.group(1);
ModuleImport moduleImport = findModuleImport(currentModule, prefix);
- foundModule = schemaContext.findModuleByName(moduleImport.getModuleName(), moduleImport.getRevision());
+ foundModule = schemaContext.findModule(moduleImport.getModuleName(), moduleImport.getRevision()).orElse(null);
checkNotNull(foundModule, format("Module not found in SchemaContext by %s", moduleImport));
localSIName = m.group(2);
} else {
import static com.google.common.base.Preconditions.checkNotNull;
import static java.lang.String.format;
import static org.opendaylight.controller.config.yangjmxgenerator.ConfigConstants.SERVICE_TYPE_Q_NAME;
+
import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.HashMap;
private final QName yangModuleQName;
private final boolean registerToOsgi;
- private ServiceInterfaceEntry(IdentitySchemaNode id, String packageName, QName yangModuleQName) {
+ private ServiceInterfaceEntry(final IdentitySchemaNode id, final String packageName, final QName yangModuleQName) {
this(Optional.<ServiceInterfaceEntry> absent(), id, packageName, yangModuleQName);
}
- private ServiceInterfaceEntry(Optional<ServiceInterfaceEntry> base,
- IdentitySchemaNode id, String packageName, QName yangModuleQName) {
+ private ServiceInterfaceEntry(final Optional<ServiceInterfaceEntry> base,
+ final IdentitySchemaNode id, final String packageName, final QName yangModuleQName) {
checkNotNull(base);
this.maybeBaseCache = base;
List<UnknownSchemaNode> unknownSchemaNodes = id.getUnknownSchemaNodes();
this.registerToOsgi = !disableOsgiServiceRegistration;
this.exportedOsgiClassName = exportedOsgiClassNames.get(0);
qName = id.getQName();
- nullableDescription = id.getDescription();
+ nullableDescription = id.getDescription().orElse(null);
typeName = getSimpleName(exportedOsgiClassName) + CLASS_NAME_SUFFIX;
this.packageName = packageName;
this.yangModuleQName = yangModuleQName;
}
- private static final String getSimpleName(String fullyQualifiedName) {
+ private static final String getSimpleName(final String fullyQualifiedName) {
int lastDotPosition = fullyQualifiedName.lastIndexOf(".");
return fullyQualifiedName.substring(lastDotPosition + 1);
}
* @return Map of QNames as keys and ServiceInterfaceEntry instances as
* values
*/
- public static Map<QName, ServiceInterfaceEntry> create(Module currentModule,
- String packageName,Map<IdentitySchemaNode, ServiceInterfaceEntry> definedSEItracker) {
+ public static Map<QName, ServiceInterfaceEntry> create(final Module currentModule,
+ final String packageName,final Map<IdentitySchemaNode, ServiceInterfaceEntry> definedSEItracker) {
LOG.debug("Generating ServiceInterfaces from {} to package {}",
currentModule.getNamespace(), packageName);
.hasNext();) {
IdentitySchemaNode identity = iterator.next();
ServiceInterfaceEntry created = null;
- if (identity.getBaseIdentity() == null) {
+ if (identity.getBaseIdentities().isEmpty()) {
// this can happen while loading config module, just skip
// the identity
continue;
- } else if (identity.getBaseIdentity().getQName()
+ } else if (identity.getBaseIdentities().iterator().next().getQName()
.equals(SERVICE_TYPE_Q_NAME)) {
// this is a base type
created = new ServiceInterfaceEntry(identity, packageName, ModuleUtil.getQName(currentModule));
} else {
ServiceInterfaceEntry foundBase = definedSEItracker
- .get(identity.getBaseIdentity());
+ .get(identity.getBaseIdentities().iterator().next());
// derived type, did we convert the parent?
if (foundBase != null) {
created = new ServiceInterfaceEntry(
}
@Override
- public boolean equals(Object o) {
+ public boolean equals(final Object o) {
if (this == o) {
return true;
}
import com.google.common.base.Preconditions;
import java.util.Arrays;
import java.util.List;
+import java.util.Optional;
import javax.management.openmbean.ArrayType;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenDataException;
this.typeDefinition = CompatUtils.compatLeafType(leaf);
this.typeProviderWrapper = typeProviderWrapper;
- this.nullableDefault = leaf.getDefault();
- this.nullableDefaultWrappedForCode = leaf.getDefault() == null ? null : typeProviderWrapper.getDefault(leaf);
- this.nullableDescription = leaf.getDescription();
+
+ final Optional<? extends Object> typeDefault = leaf.getType().getDefaultValue();
+ if (typeDefault.isPresent()) {
+ nullableDefault = (String) typeDefault.get();
+ nullableDefaultWrappedForCode = typeProviderWrapper.getDefault(leaf);
+ } else {
+ nullableDefault = null;
+ nullableDefaultWrappedForCode = null;
+ }
+
+ this.nullableDescription = leaf.getDescription().orElse(null);
}
public JavaAttribute(final LeafListSchemaNode leaf,
this.typeDefinition = leaf.getType();
this.typeProviderWrapper = typeProviderWrapper;
this.nullableDefault = this.nullableDefaultWrappedForCode = null;
- this.nullableDescription = leaf.getDescription();
+ this.nullableDescription = leaf.getDescription().orElse(null);
}
public boolean isUnion() {
if (this == o) {
return true;
}
- if ((o == null) || (getClass() != o.getClass())) {
+ if (o == null || getClass() != o.getClass()) {
return false;
}
if (!super.equals(o)) {
@Override
public int hashCode() {
int result = super.hashCode();
- result = (31 * result) + (this.type != null ? this.type.hashCode() : 0);
- result = (31
- * result)
+ result = 31 * result + (this.type != null ? this.type.hashCode() : 0);
+ result = 31
+ * result
+ (this.nullableDescription != null ? this.nullableDescription.hashCode()
: 0);
- result = (31 * result)
+ result = 31 * result
+ (this.nullableDefault != null ? this.nullableDefault.hashCode() : 0);
return result;
}
final TOAttribute innerAttribute = TOAttribute.create(node, typeProvider, packageName);
- return new ListAttribute(node, innerAttribute, node.getDescription());
+ return new ListAttribute(node, innerAttribute, node.getDescription().orElse(null));
}
public static ListAttribute create(final LeafListSchemaNode node,
final JavaAttribute innerAttribute = new JavaAttribute(node, typeProvider);
- return new ListAttribute(node, innerAttribute, node.getDescription());
+ return new ListAttribute(node, innerAttribute, node.getDescription().orElse(null));
}
ListAttribute(final DataSchemaNode attrNode, final TypedAttribute innerAttribute,
@Override
public int hashCode() {
int result = super.hashCode();
- result = (31
- * result)
+ result = 31
+ * result
+ (this.nullableDescription != null ? this.nullableDescription.hashCode()
: 0);
- result = (31 * result)
+ result = 31 * result
+ (this.nullableDefault != null ? this.nullableDefault.hashCode() : 0);
return result;
}
if (this == o) {
return true;
}
- if ((o == null) || (getClass() != o.getClass())) {
+ if (o == null || getClass() != o.getClass()) {
return false;
}
if (!super.equals(o)) {
// Transfer Object: get the leaves
final Map<String, AttributeIfc> map = new HashMap<>();
final Map<String, String> attributeNameMap = new HashMap<>();
- for (final DataSchemaNode dataSchemaNode : containerSchemaNode
- .getChildNodes()) {
+ for (final DataSchemaNode dataSchemaNode : containerSchemaNode.getChildNodes()) {
try {
final String yangName = dataSchemaNode.getQName().getLocalName();
- map.put(yangName,
- createInnerAttribute(dataSchemaNode,
- typeProviderWrapper, packageName));
+ map.put(yangName, createInnerAttribute(dataSchemaNode, typeProviderWrapper, packageName));
} catch (final IllegalArgumentException e) {
throw new IllegalStateException("Unable to create TO", e);
}
}
return new TOAttribute(containerSchemaNode, map, attributeNameMap,
- containerSchemaNode.getDescription(), packageName);
+ containerSchemaNode.getDescription().orElse(null), packageName);
}
private static AttributeIfc createInnerAttribute(
final Class<? extends DataSchemaNode> type = isAllowedType(dataSchemaNode);
if (type.equals(LeafSchemaNode.class)) {
- return new JavaAttribute((LeafSchemaNode) dataSchemaNode,
- typeProviderWrapper);
+ return new JavaAttribute((LeafSchemaNode) dataSchemaNode, typeProviderWrapper);
} else if (type.equals(ListSchemaNode.class)) {
- return ListAttribute.create((ListSchemaNode) dataSchemaNode,
- typeProviderWrapper, packageName);
+ return ListAttribute.create((ListSchemaNode) dataSchemaNode, typeProviderWrapper, packageName);
} else if (type.equals(LeafListSchemaNode.class)) {
- return ListAttribute.create((LeafListSchemaNode) dataSchemaNode,
- typeProviderWrapper);
+ return ListAttribute.create((LeafListSchemaNode) dataSchemaNode, typeProviderWrapper);
} else if (type.equals(ContainerSchemaNode.class)) {
- return TOAttribute.create((ContainerSchemaNode) dataSchemaNode,
- typeProviderWrapper, packageName);
+ return TOAttribute.create((ContainerSchemaNode) dataSchemaNode, typeProviderWrapper, packageName);
}
throw new IllegalStateException("This should never happen");
private static Class<? extends DataSchemaNode> isAllowedType(
final DataSchemaNode dataSchemaNode) {
for (final Class<? extends DataSchemaNode> allowedType : ALLOWED_CHILDREN) {
- if (allowedType.isAssignableFrom(dataSchemaNode.getClass()) == true) {
+ if (allowedType.isAssignableFrom(dataSchemaNode.getClass())) {
return allowedType;
}
}
if (this == o) {
return true;
}
- if ((o == null) || (getClass() != o.getClass())) {
+ if (o == null || getClass() != o.getClass()) {
return false;
}
if (!super.equals(o)) {
@Override
public int hashCode() {
int result = super.hashCode();
- result = (31
- * result)
+ result = 31
+ * result
+ (this.nullableDescription != null ? this.nullableDescription.hashCode()
: 0);
- result = (31 * result)
+ result = 31 * result
+ (this.nullableDefault != null ? this.nullableDefault.hashCode() : 0);
- result = (31
- * result)
+ result = 31
+ * result
+ (this.yangNameToAttributeMap != null ? this.yangNameToAttributeMap
.hashCode() : 0);
return result;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
+
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
import java.io.InputStream;
import java.util.ArrayList;
@Before
public void loadYangFiles() throws Exception {
- final List<InputStream> yangISs = new ArrayList<>();
- yangISs.addAll(getStreams("/test-config-threads.yang",
- "/test-config-threads-java.yang",
- "/config-bgp-listener-impl.yang", "/ietf-inet-types.yang",
- "/config-jmx-it.yang", "/config-jmx-it-impl.yang",
- "/test-config-files.yang", "/test-config-files1.yang"));
+ final List<String> yangResources = new ArrayList<>();
+ yangResources.add("/test-config-threads.yang");
+ yangResources.add("/test-config-threads-java.yang");
+ yangResources.add("/config-bgp-listener-impl.yang");
+ yangResources.add("/ietf-inet-types.yang");
+ yangResources.add("/config-jmx-it.yang");
+ yangResources.add("/config-jmx-it-impl.yang");
+ yangResources.add("/test-config-files.yang");
+ yangResources.add("/test-config-files1.yang");
- yangISs.addAll(getConfigApiYangInputStreams());
+ yangResources.addAll(getConfigApiYangs());
+
+ this.context = YangParserTestUtils.parseYangResources(AbstractYangTest.class, yangResources);
- this.context = YangParserTestUtils.parseYangStreams(yangISs);
- // close ISs
- for (final InputStream is : yangISs) {
- is.close();
- }
this.namesToModules = YangModelSearchUtils.mapModulesByNames(this.context
.getModules());
this.configModule = this.namesToModules.get(ConfigConstants.CONFIG_MODULE);
this.jmxImplModule = this.namesToModules.get("config-jmx-it-impl");
this.testFilesModule = this.namesToModules.get("test-config-files");
this.testFiles1Module = this.namesToModules.get("test-config-files1");
-
}
- public static List<InputStream> getConfigApiYangInputStreams() {
- return getStreams("/META-INF/yang/config@2013-04-05.yang", "/META-INF/yang/rpc-context@2013-06-17.yang");
+ public static List<String> getConfigApiYangs() {
+ return ImmutableList.of("/META-INF/yang/config@2013-04-05.yang", "/META-INF/yang/rpc-context@2013-06-17.yang");
}
public Map<QName, IdentitySchemaNode> mapIdentitiesByQNames(final Module module) {
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
+
import com.google.common.base.Preconditions;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.InputStream;
+import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.NameConflictException;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.YangModelSearchUtils;
import org.opendaylight.mdsal.binding.yang.types.TypeProviderImpl;
+import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.slf4j.Logger;
public class ModuleMXBeanEntryNameConflictTest extends AbstractYangTest {
- private static final Logger LOG = LoggerFactory
- .getLogger(ModuleMXBeanEntryNameConflictTest.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ModuleMXBeanEntryNameConflictTest.class);
public static final String PACKAGE_NAME = "pack2";
- Map<File, String> testedFilesToYangModules = new HashMap<>();
- Map<String, String> testedYangModulesToExpectedConflictingName = new HashMap<>();
-
- @Ignore
- @Test
- public void testNameConflicts() throws Exception {
- prepareSamples();
- prepareExceptionAssertions();
-
- for (final Map.Entry<File, String> currentTestEntry : this.testedFilesToYangModules
- .entrySet()) {
- final String moduleName = currentTestEntry.getValue();
- final File yangFile = currentTestEntry.getKey();
- final Module testedModule = loadYangs(yangFile, moduleName);
-
- try {
- LOG.debug("Testing {}", yangFile);
- ModuleMXBeanEntry.create(testedModule,
- new HashMap<>(), this.context,
- new TypeProviderWrapper(new TypeProviderImpl(this.context)),
- PACKAGE_NAME);
- fail(yangFile.toString()
- + " did not cause a name conflict and should");
- } catch (final NameConflictException e) {
- assertEquals(
- this.testedYangModulesToExpectedConflictingName
- .get(moduleName),
- e.getConflictingName());
- }
- }
- }
-
- private void prepareSamples() {
- final File first = new File(getClass().getResource(
- "/duplicates/config-test-duplicate-attribute-in-list.yang")
- .getFile());
- final File dir = first.getParentFile();
-
- for (final File testYang : dir.listFiles()) {
- final String moduleName = getYangModuleName(testYang.getName());
- this.testedFilesToYangModules.put(testYang, moduleName);
- }
- }
- private void prepareExceptionAssertions() {
- this.testedYangModulesToExpectedConflictingName.put(
- "config-test-duplicate-attribute", "DtoA");
- this.testedYangModulesToExpectedConflictingName.put(
- "config-test-duplicate-attribute-in-list", "DtoA");
- this.testedYangModulesToExpectedConflictingName.put(
- "config-test-duplicate-attribute-runtime-bean", "DtoA");
- this.testedYangModulesToExpectedConflictingName.put(
- "config-test-generated-attributes-name-conflict", "StateB");
- this.testedYangModulesToExpectedConflictingName.put(
- "config-test-runtime-bean-list-name-conflict",
+ private final List<String> testedModules = ImmutableList.of(
+ "config-test-duplicate-attribute-in-list",
+ "config-test-duplicate-attribute-in-runtime-and-mxbean",
+ "config-test-duplicate-attribute-runtime-bean",
+ "config-test-duplicate-attribute",
+ "config-test-generated-attributes-name-conflict",
+ "config-test-runtime-bean-list-name-conflict2",
+ "config-test-runtime-bean-list-name-conflict",
+ "config-test-runtime-bean-name-conflict2",
+ "config-test-runtime-bean-name-conflict");
+ private final Map<String, String> testedYangModulesToExpectedConflictingName = new HashMap<>();
+
+ @Before
+ public void setup() {
+ testedYangModulesToExpectedConflictingName.put("config-test-duplicate-attribute", "DtoA");
+ testedYangModulesToExpectedConflictingName.put("config-test-duplicate-attribute-in-list", "DtoA");
+ testedYangModulesToExpectedConflictingName.put("config-test-duplicate-attribute-runtime-bean", "DtoA");
+ testedYangModulesToExpectedConflictingName.put("config-test-generated-attributes-name-conflict", "StateB");
+ testedYangModulesToExpectedConflictingName.put("config-test-runtime-bean-list-name-conflict",
"StateARuntimeMXBean");
- this.testedYangModulesToExpectedConflictingName.put(
- "config-test-runtime-bean-list-name-conflict2",
+ testedYangModulesToExpectedConflictingName.put("config-test-runtime-bean-list-name-conflict2",
"StateARuntimeMXBean");
- this.testedYangModulesToExpectedConflictingName
- .put("config-test-runtime-bean-name-conflict", "StateARuntimeMXBean");
- this.testedYangModulesToExpectedConflictingName.put(
- "config-test-runtime-bean-name-conflict2",
+ testedYangModulesToExpectedConflictingName.put("config-test-runtime-bean-name-conflict",
"StateARuntimeMXBean");
- this.testedYangModulesToExpectedConflictingName.put(
- "config-test-duplicate-attribute-in-runtime-and-mxbean",
- "port");
- }
-
- private static String getYangModuleName(final String name) {
- final int startIndex = 0;
- final int endIndex = name.indexOf(".yang");
- return name.substring(startIndex, endIndex);
+ testedYangModulesToExpectedConflictingName.put("config-test-runtime-bean-name-conflict2",
+ "StateARuntimeMXBean");
+ testedYangModulesToExpectedConflictingName.put("config-test-duplicate-attribute-in-runtime-and-mxbean", "port");
}
- private Module loadYangs(final File testedModule, final String moduleName)
- throws Exception {
- final List<InputStream> yangISs = new ArrayList<>();
- yangISs.addAll(getStreams("/ietf-inet-types.yang"));
-
- yangISs.add(new FileInputStream(testedModule));
+ private Module loadYangs(final String testedModule, final String moduleName) {
+ final List<String> yangs = new ArrayList<>();
+ yangs.add("/ietf-inet-types.yang");
+ yangs.add("/duplicates/" + testedModule + YangConstants.RFC6020_YANG_FILE_EXTENSION);
+ yangs.addAll(getConfigApiYangs());
- yangISs.addAll(getConfigApiYangInputStreams());
-
- this.context = YangParserTestUtils.parseYangStreams(yangISs);
- // close ISs
- for (final InputStream is : yangISs) {
- is.close();
- }
- this.namesToModules = YangModelSearchUtils.mapModulesByNames(this.context
- .getModules());
+ this.context = YangParserTestUtils.parseYangResources(ModuleMXBeanEntryNameConflictTest.class, yangs);
+ this.namesToModules = YangModelSearchUtils.mapModulesByNames(this.context.getModules());
this.configModule = this.namesToModules.get(ConfigConstants.CONFIG_MODULE);
final Module module = this.namesToModules.get(moduleName);
- Preconditions.checkNotNull(module, "Cannot get module %s from %s",
- moduleName, this.namesToModules.keySet());
+ Preconditions.checkNotNull(module, "Cannot get module %s from %s", moduleName, this.namesToModules.keySet());
return module;
}
+ @Ignore
+ @Test
+ public void testNameConflicts() {
+ for (final String moduleName : testedModules) {
+ final Module testedModule = loadYangs(moduleName, moduleName);
+
+ try {
+ LOG.debug("Testing {}", moduleName);
+ ModuleMXBeanEntry.create(testedModule, new HashMap<>(), this.context,
+ new TypeProviderWrapper(new TypeProviderImpl(this.context)), PACKAGE_NAME);
+ fail(moduleName + " did not cause a name conflict and should");
+ } catch (final NameConflictException e) {
+ assertEquals(this.testedYangModulesToExpectedConflictingName.get(moduleName), e.getConflictingName());
+ }
+ }
+ }
}
import com.google.common.collect.Sets;
import java.net.URI;
import java.net.URISyntaxException;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Collections;
-import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import org.opendaylight.mdsal.binding.model.util.Types;
import org.opendaylight.mdsal.binding.yang.types.TypeProviderImpl;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
public static final String PACKAGE_NAME = "pack2";
protected static final URI THREADS_NAMESPACE;
- protected static final Date THREADS_REVISION_DATE;
+ protected static final Revision THREADS_REVISION_DATE = Revision.of("2013-04-09");
static {
try {
- THREADS_NAMESPACE = new URI(ConfigConstants.CONFIG_NAMESPACE
- + ":threads");
+ THREADS_NAMESPACE = new URI(ConfigConstants.CONFIG_NAMESPACE + ":threads");
} catch (final URISyntaxException e) {
- throw new Error(e);
- }
- final SimpleDateFormat revisionFormat = new SimpleDateFormat("yyyy-MM-dd");
- try {
- THREADS_REVISION_DATE = revisionFormat.parse("2013-04-09");
- } catch (final ParseException e) {
- throw new Error(e);
+ throw new ExceptionInInitializerError(e);
}
}
import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
import org.opendaylight.mdsal.binding.yang.types.TypeProviderImpl;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
@Test
public void createRuntimeBean() {
- final ChoiceCaseNode caseNode = Mockito.mock(ChoiceCaseNode.class);
+ final CaseSchemaNode caseNode = Mockito.mock(CaseSchemaNode.class);
doReturn(new HashSet<LeafSchemaNode>()).when(caseNode).getChildNodes();
doReturn(new ArrayList<UnknownSchemaNode>()).when(caseNode)
.getUnknownSchemaNodes();
import static org.apache.commons.lang3.StringUtils.capitalize;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
+
import com.google.common.base.Optional;
import java.net.URI;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
-import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry.Rpc;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
public class RuntimeRegistratorTest {
// TODO add more tests
final DataNodeContainer nodeContainer = mock(DataNodeContainer.class);
doReturn("DataSchemaNode").when(nodeContainer).toString();
return new RuntimeBeanEntry("pa.cka.ge", nodeContainer,
- "module-name", "ModuleName", true, Optional.<String> absent(),
- Collections.<AttributeIfc> emptyList(), children,
- Collections.<Rpc> emptySet());
+ "module-name", "ModuleName", true, Optional.absent(),
+ Collections.emptyList(), children, Collections.emptySet());
}
protected RuntimeBeanEntry prepareChildRB(final List<RuntimeBeanEntry> children,
doReturn("DataSchemaNode").when(nodeContainer).toString();
return new RuntimeBeanEntry("pa.cka.ge", nodeContainer,
prefix + "child-name", capitalize(prefix) + "ChildName", false,
- Optional.<String> absent(),
- Collections.<AttributeIfc> emptyList(), children,
- Collections.<Rpc> emptySet());
+ Optional.absent(), Collections.emptyList(), children, Collections.emptySet());
}
@Test
public void testHierarchy() {
final LeafSchemaNode leaf = mock(LeafSchemaNode.class);
- doReturn(new QName(URI.create("urn:x"), "leaf-local-name")).when(leaf)
- .getQName();
+ doReturn(QName.create(URI.create("urn:x"), "leaf-local-name")).when(leaf).getQName();
doReturn(Collections.emptyList()).when(leaf).getUnknownSchemaNodes();
- doReturn(null).when(leaf).getDefault();
- doReturn(null).when(leaf).getDescription();
+ doReturn(java.util.Optional.empty()).when(leaf).getDescription();
+
+ final StringTypeDefinition leafType = mock(StringTypeDefinition.class);
+ doReturn(java.util.Optional.empty()).when(leafType).getDefaultValue();
+ doReturn(leafType).when(leaf).getType();
final TypeProviderWrapper typeProviderWrapper = mock(TypeProviderWrapper.class);
final Type mockedType = mock(Type.class);
doReturn(mockedType).when(typeProviderWrapper).getType(leaf);
doReturn("java.lang.String").when(mockedType).getFullyQualifiedName();
-
}
}
public class SchemaContextTest extends AbstractYangTest {
- IdentitySchemaNode findIdentityByQName(Module module, QName qName) {
+ IdentitySchemaNode findIdentityByQName(final Module module, final QName qName) {
Map<QName, IdentitySchemaNode> mapIdentitiesByQNames = mapIdentitiesByQNames(module);
IdentitySchemaNode found = mapIdentitiesByQNames.get(qName);
assertNotNull(found);
// all except scheduled-threadpool should have base set to
// serviceType
if (localName.equals("scheduled-threadpool") == false) {
- assertEquals(serviceType, id.getBaseIdentity());
+ assertEquals(serviceType, id.getBaseIdentities().iterator().next());
}
}
assertNotNull(eventBusSchemaNode);
usn.getNodeType());
}
- private void assertAllIdentitiesAreExpected(
- Module module,
- Map<String /* identity name */, Optional<QName>> expectedIdentitiesToBases) {
+ private static void assertAllIdentitiesAreExpected(final Module module,
+ final Map<String /* identity name */, Optional<QName>> expectedIdentitiesToBases) {
Map<String /* identity name */, Optional<QName>> copyOfExpectedNames = new HashMap<>(
expectedIdentitiesToBases);
for (IdentitySchemaNode id : module.getIdentities()) {
.remove(localName);
if (maybeExpectedBaseQName.isPresent()) {
assertEquals("Unexpected base identity of " + localName,
- maybeExpectedBaseQName.get(), id.getBaseIdentity()
- .getQName());
+ maybeExpectedBaseQName.get(), id.getBaseIdentities().iterator().next().getQName());
}
}
assertEquals("Expected identities not found " + copyOfExpectedNames,
@Test
public void testReadingIdentities_threadsJavaModule() {
- Map<String /* identity name */, Optional<QName>> expectedIdentitiesToBases = new HashMap<String, Optional<QName>>(){
- private static final long serialVersionUID = 1L;
+ Map<String /* identity name */, Optional<QName>> expected = new HashMap<>();
+ expected.put(ModuleMXBeanEntryTest.EVENTBUS_MXB_NAME, Optional.of(MODULE_TYPE_Q_NAME));
+ expected.put(ModuleMXBeanEntryTest.ASYNC_EVENTBUS_MXB_NAME, Optional.of(MODULE_TYPE_Q_NAME));
+ expected.put(ModuleMXBeanEntryTest.THREADFACTORY_NAMING_MXB_NAME, Optional.of(MODULE_TYPE_Q_NAME));
+ expected.put(ModuleMXBeanEntryTest.THREADPOOL_DYNAMIC_MXB_NAME, Optional.of(MODULE_TYPE_Q_NAME));
+ expected.put("thread-rpc-context", Optional.<QName>absent());
+ expected.put(ModuleMXBeanEntryTest.THREADPOOL_REGISTRY_IMPL_NAME, Optional.of(MODULE_TYPE_Q_NAME));
- {
- put(ModuleMXBeanEntryTest.EVENTBUS_MXB_NAME, Optional.of(MODULE_TYPE_Q_NAME));
- put(ModuleMXBeanEntryTest.ASYNC_EVENTBUS_MXB_NAME, Optional.of(MODULE_TYPE_Q_NAME));
- put(ModuleMXBeanEntryTest.THREADFACTORY_NAMING_MXB_NAME, Optional.of(MODULE_TYPE_Q_NAME));
- put(ModuleMXBeanEntryTest.THREADPOOL_DYNAMIC_MXB_NAME, Optional.of(MODULE_TYPE_Q_NAME));
- put("thread-rpc-context", Optional.<QName>absent());
- put(ModuleMXBeanEntryTest.THREADPOOL_REGISTRY_IMPL_NAME, Optional.of(MODULE_TYPE_Q_NAME));
- }
- };
-
- assertAllIdentitiesAreExpected(threadsJavaModule,
- expectedIdentitiesToBases);
+ assertAllIdentitiesAreExpected(threadsJavaModule, expected);
}
-
}
import com.google.common.collect.Sets;
import java.net.URI;
import java.net.URISyntaxException;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
import java.util.Arrays;
-import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import org.hamcrest.CoreMatchers;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
public class ServiceInterfaceEntryTest extends AbstractYangTest {
+ ".java, ThreadFactoryServiceInterface.java, ThreadPoolServiceInterface.java]");
private static final URI THREADS_NAMESPACE;
- private static final Date THREADS_REVISION_DATE;
+ private static final Revision THREADS_REVISION_DATE = Revision.of("2013-04-09");
static {
try {
- THREADS_NAMESPACE = new URI(ConfigConstants.CONFIG_NAMESPACE
- + ":threads");
+ THREADS_NAMESPACE = new URI(ConfigConstants.CONFIG_NAMESPACE + ":threads");
} catch (URISyntaxException e) {
- throw new Error(e);
- }
- SimpleDateFormat revisionFormat = new SimpleDateFormat("yyyy-MM-dd");
- try {
- THREADS_REVISION_DATE = revisionFormat.parse("2013-04-09");
- } catch (ParseException e) {
- throw new Error(e);
+ throw new ExceptionInInitializerError(e);
}
}
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import com.google.common.collect.Lists;
-import java.io.InputStream;
+import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import org.opendaylight.controller.config.yangjmxgenerator.ConfigConstants;
@Test
public void testStopOnUnknownLanguageExtension() throws Exception {
- List<InputStream> yangISs = Lists.newArrayList(getClass()
- .getResourceAsStream("test-ifcWithUnknownExtension.yang"));
- yangISs.addAll(getConfigApiYangInputStreams());
+ List<String> yangs = new ArrayList<>();
+ yangs.addAll(getConfigApiYangs());
+ yangs.add("test-ifcWithUnknownExtension.yang");
+
+ context = YangParserTestUtils.parseYangResources(UnknownExtensionTest.class, yangs);
+ namesToModules = YangModelSearchUtils.mapModulesByNames(context.getModules());
+ configModule = namesToModules.get(ConfigConstants.CONFIG_MODULE);
+ threadsModule = namesToModules.get(ConfigConstants.CONFIG_THREADS_MODULE);
try {
- context = YangParserTestUtils.parseYangStreams(yangISs);
- namesToModules = YangModelSearchUtils.mapModulesByNames(context.getModules());
- configModule = namesToModules.get(ConfigConstants.CONFIG_MODULE);
- threadsModule = namesToModules.get(ConfigConstants.CONFIG_THREADS_MODULE);
- try {
- super.testCreateFromIdentities();
- fail();
- } catch (IllegalStateException e) {
- assertTrue(e.getMessage(),
- e.getMessage().startsWith("Unexpected unknown schema node."));
- }
- } finally {
- for (InputStream is : yangISs) {
- is.close();
- }
+ super.testCreateFromIdentities();
+ fail();
+ } catch (IllegalStateException e) {
+ assertTrue(e.getMessage(),
+ e.getMessage().startsWith("Unexpected unknown schema node."));
}
}
import org.junit.Test;
import org.opendaylight.controller.cluster.access.ABIVersion;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
public class ConnectClientSuccessTest extends AbstractRequestSuccessTest<ConnectClientSuccess> {
- private static final DataTree TREE = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
+ private static final DataTree TREE = new InMemoryDataTreeFactory().create(
+ DataTreeConfiguration.DEFAULT_OPERATIONAL);
private static final ActorSystem SYSTEM = ActorSystem.create("test");
private static final ActorRef ACTOR_REF = TestProbe.apply(SYSTEM).ref();
private static final ActorSelection ACTOR_SELECTION = ActorSelection.apply(ACTOR_REF, "foo");
*/
package org.opendaylight.controller.md.sal.binding.impl;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
UNKNOWN;
static BindingStructuralType from(final DataTreeCandidateNode domChildNode) {
- final Optional<NormalizedNode<?, ?>> dataBased = domChildNode.getDataAfter().or(domChildNode.getDataBefore());
- if(dataBased.isPresent()) {
+ Optional<NormalizedNode<?, ?>> dataBased = domChildNode.getDataAfter();
+ if (!dataBased.isPresent()) {
+ dataBased = domChildNode.getDataBefore();
+ }
+ if (dataBased.isPresent()) {
return from(dataBased.get());
}
return from(domChildNode.getIdentifier());
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableBiMap;
import java.lang.reflect.Method;
-import java.net.URI;
import java.util.AbstractMap.SimpleEntry;
import java.util.Collection;
-import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
private Module getModuleBlocking(final Class<?> modeledClass) {
final QNameModule moduleName = BindingReflections.getQNameModule(modeledClass);
- final URI namespace = moduleName.getNamespace();
- final Date revision = moduleName.getRevision();
- Module module = runtimeContext().getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision);
- if ((module == null) && this.futureSchema.waitForSchema(namespace, revision)) {
- module = runtimeContext().getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision);
+ Module module = runtimeContext().getSchemaContext().findModule(moduleName).orElse(null);
+ if (module == null && this.futureSchema.waitForSchema(moduleName)) {
+ module = runtimeContext().getSchemaContext().findModule(moduleName).orElse(null);
}
Preconditions.checkState(module != null, "Schema for %s is not available.", modeledClass);
return module;
private Method findRpcMethod(final Class<? extends RpcService> key, final RpcDefinition rpcDef)
throws NoSuchMethodException {
final String methodName = BindingMapping.getMethodName(rpcDef.getQName());
- if ((rpcDef.getInput() != null) && isExplicitStatement(rpcDef.getInput())) {
+ if (rpcDef.getInput() != null && isExplicitStatement(rpcDef.getInput())) {
final Class<?> inputClz = runtimeContext().getClassForSchema(rpcDef.getInput());
return key.getMethod(methodName, inputClz);
}
}
private static boolean isExplicitStatement(final ContainerSchemaNode node) {
- return (node instanceof EffectiveStatement)
- && (((EffectiveStatement) node).getDeclared().getStatementSource() == StatementSource.DECLARATION);
+ return node instanceof EffectiveStatement
+ && ((EffectiveStatement) node).getDeclared().getStatementSource() == StatementSource.DECLARATION;
}
private BindingRuntimeContext runtimeContext() {
import com.google.common.base.Predicate;
import com.google.common.base.Throwables;
import com.google.common.util.concurrent.SettableFuture;
-import java.net.URI;
import java.util.Collection;
import java.util.Collections;
-import java.util.Date;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.yangtools.yang.binding.Augmentation;
+import org.opendaylight.yangtools.yang.common.QNameModule;
class FutureSchema implements AutoCloseable {
return schema != null;
}
- boolean waitForSchema(final URI namespace, final Date revision) {
+ boolean waitForSchema(final QNameModule module) {
return addPostponedOpAndWait(new FutureSchemaPredicate() {
@Override
public boolean apply(final BindingRuntimeContext input) {
- return input.getSchemaContext().findModuleByNamespaceAndRevision(namespace, revision) != null;
+ return input.getSchemaContext().findModule(module).isPresent();
}
});
}
*/
package org.opendaylight.controller.md.sal.binding.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
+import java.util.Optional;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
import org.opendaylight.yangtools.yang.binding.Augmentation;
package org.opendaylight.controller.md.sal.binding.impl;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.common.QName;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+
import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.Multimaps;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.SetMultimap;
import com.google.common.util.concurrent.Uninterruptibles;
import java.lang.reflect.Method;
import java.net.URI;
-import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
+import javassist.ClassPool;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.test.AbstractSchemaAwareTest;
import org.opendaylight.mdsal.binding.dom.codec.gen.impl.DataObjectSerializerGenerator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.util.AbstractSchemaContext;
-import javassist.ClassPool;
public class BindingNormalizedCodecTest extends AbstractSchemaAwareTest {
static class EmptySchemaContext extends AbstractSchemaContext {
@Override
public Set<Module> getModules() {
- return Collections.emptySet();
+ return ImmutableSet.of();
}
@Override
- protected Map<ModuleIdentifier, String> getIdentifiersToSources() {
- return Collections.emptyMap();
+ protected Map<QNameModule, Module> getModuleMap() {
+ return ImmutableMap.of();
}
@Override
protected SetMultimap<URI, Module> getNamespaceToModules() {
- return Multimaps.forMap(Collections.emptyMap());
+ return ImmutableSetMultimap.of();
}
@Override
protected SetMultimap<String, Module> getNameToModules() {
- return Multimaps.forMap(Collections.emptyMap());
+ return ImmutableSetMultimap.of();
}
}
}
private static final String TLL_NAME = "foo";
private static final TopLevelListKey TLL_KEY = new TopLevelListKey(TLL_NAME);
- private static final InstanceIdentifier<TopLevelList> TLL_INSTANCE_ID_BA = InstanceIdentifier.builder(Top.class) //
- .child(TopLevelList.class, TLL_KEY).toInstance();
+ private static final InstanceIdentifier<TopLevelList> TLL_INSTANCE_ID_BA = InstanceIdentifier.builder(Top.class)
+ .child(TopLevelList.class, TLL_KEY).build();
private static final InstanceIdentifier<TreeComplexUsesAugment> AUGMENT_WILDCARDED_PATH = InstanceIdentifier
- .builder(Top.class).child(TopLevelList.class).augmentation(TreeComplexUsesAugment.class).toInstance();
+ .builder(Top.class).child(TopLevelList.class).augmentation(TreeComplexUsesAugment.class).build();
private static final InstanceIdentifier<TreeComplexUsesAugment> AUGMENT_TLL_PATH = InstanceIdentifier
- .builder(Top.class).child(TopLevelList.class, TLL_KEY).augmentation(TreeComplexUsesAugment.class).toInstance();
+ .builder(Top.class).child(TopLevelList.class, TLL_KEY).augmentation(TreeComplexUsesAugment.class).build();
@Test
public void writeNodeListenAugment() throws Exception {
final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
- TopLevelList tll = new TopLevelListBuilder() //
- .setKey(TLL_KEY) //
+ TopLevelList tll = new TopLevelListBuilder()
+ .setKey(TLL_KEY)
.addAugmentation(TreeComplexUsesAugment.class, treeComplexUsesAugment("one")).build();
transaction.put(LogicalDatastoreType.OPERATIONAL, TLL_INSTANCE_ID_BA, tll, true);
transaction.submit().get(5, TimeUnit.SECONDS);
transaction2.submit().get(5, TimeUnit.SECONDS);
TreeComplexUsesAugment readedAug = dataBroker.newReadOnlyTransaction().read(
- LogicalDatastoreType.OPERATIONAL, AUGMENT_TLL_PATH).checkedGet(5, TimeUnit.SECONDS).get();
+ LogicalDatastoreType.OPERATIONAL, AUGMENT_TLL_PATH).get(5, TimeUnit.SECONDS).get();
assertEquals("two", readedAug.getContainerWithUses().getLeafFromGrouping());
}
- private TreeComplexUsesAugment treeComplexUsesAugment(final String value) {
- return new TreeComplexUsesAugmentBuilder() //
- .setContainerWithUses(new ContainerWithUsesBuilder().setLeafFromGrouping(value).build()) //
+ private static TreeComplexUsesAugment treeComplexUsesAugment(final String value) {
+ return new TreeComplexUsesAugmentBuilder()
+ .setContainerWithUses(new ContainerWithUsesBuilder().setLeafFromGrouping(value).build())
.build();
}
}
private static final List1Key LIST1_KEY = new List1Key(LIST1_NAME);
private static final InstanceIdentifier<TopLevelList> TLL_INSTANCE_ID_BA = InstanceIdentifier.builder(Top.class) //
- .child(TopLevelList.class, TLL_KEY).toInstance();
+ .child(TopLevelList.class, TLL_KEY).build();
private static final InstanceIdentifier<List1> LIST1_INSTANCE_ID_BA = //
TLL_INSTANCE_ID_BA.builder() //
transaction.submit().get(5, TimeUnit.SECONDS);
Optional<List1> readList1 = dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL,
- LIST1_INSTANCE_ID_BA).checkedGet(1000, TimeUnit.MILLISECONDS);
+ LIST1_INSTANCE_ID_BA).get(1000, TimeUnit.MILLISECONDS);
assertTrue(readList1.isPresent());
Optional<? extends DataObject> readList11 = dataBroker.newReadOnlyTransaction().read(
- LogicalDatastoreType.OPERATIONAL, LIST11_INSTANCE_ID_BA).checkedGet(5, TimeUnit.SECONDS);
+ LogicalDatastoreType.OPERATIONAL, LIST11_INSTANCE_ID_BA).get(5, TimeUnit.SECONDS);
assertNotNull("Readed flow should not be null.",readList11);
assertTrue(readList11.isPresent());
assertEquals(list11, readList11.get());
import static org.junit.Assert.fail;
import com.google.common.base.Optional;
+import com.google.common.io.ByteSource;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
+import java.io.IOException;
import java.io.InputStream;
-import java.util.Collections;
-import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.junit.After;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListKey;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
+import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
/**
bindingMountPointService = testContext.getBindingMountPointService();
assertNotNull(domMountPointService);
- final InputStream moduleStream = BindingReflections.getModuleInfo(
- OpendaylightTestRpcServiceService.class)
- .getModuleSourceStream();
+ final YangModuleInfo moduleInfo = BindingReflections.getModuleInfo(OpendaylightTestRpcServiceService.class);
+ assertNotNull(moduleInfo);
- assertNotNull(moduleStream);
- final List<InputStream> rpcModels = Collections.singletonList(moduleStream);
- schemaContext = YangParserTestUtils.parseYangStreams(rpcModels);
+ schemaContext = YangParserTestUtils.parseYangSources(StatementParserMode.DEFAULT_MODE, null,
+ YangTextSchemaSource.delegateForByteSource(RevisionSourceIdentifier.create(moduleInfo.getName(),
+ Revision.ofNullable(moduleInfo.getRevision())), new ByteSource() {
+
+ @Override
+ public InputStream openStream() throws IOException {
+ return moduleInfo.getModuleSourceStream();
+ }
+ }));
}
private static org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier createBITllIdentifier(
import java.util.HashMap;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
/**
* NormalizedNodeOutputStreamWriter will be used by distributed datastore to send normalized node in
protected void writeQName(final QName qname) throws IOException {
writeString(qname.getLocalName());
writeString(qname.getNamespace().toString());
- writeString(qname.getFormattedRevision());
+ writeString(qname.getRevision().map(Revision::toString).orElse(null));
}
@Override
package org.opendaylight.controller.cluster.datastore.util;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
package org.opendaylight.controller.cluster.schema.provider.impl;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.io.ByteSource;
import java.io.IOException;
import java.io.Serializable;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
private static final long serialVersionUID = -6361268518176019477L;
private final byte[] schemaSource;
- private final String revision;
+ private final Revision revision;
private final String name;
public YangTextSchemaSourceSerializationProxy(final YangTextSchemaSource source) throws IOException {
- this.revision = source.getIdentifier().getRevision();
+ this.revision = source.getIdentifier().getRevision().orElse(null);
this.name = source.getIdentifier().getName();
this.schemaSource = source.read();
}
public YangTextSchemaSource getRepresentation() {
return YangTextSchemaSource.delegateForByteSource(
- RevisionSourceIdentifier.create(name, Optional.fromNullable(revision)), ByteSource.wrap(schemaSource));
+ RevisionSourceIdentifier.create(name, revision), ByteSource.wrap(schemaSource));
}
}
import static org.junit.Assert.assertEquals;
-import com.google.common.base.Optional;
import com.google.common.io.ByteStreams;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
+import java.util.Optional;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
}
private static NormalizedNode<?, ?> createTestContainer() {
- byte[] bytes1 = {1,2,3};
+ byte[] bytes1 = {1, 2, 3};
LeafSetEntryNode<Object> entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).withValue(bytes1).build();
LeafSetEntryNode<Object> entry2 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)).withValue(bytes2).build();
- LeafSetEntryNode<Object> entry3 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
- new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, null)).withValue(null).build();
-
return TestModel.createBaseTestContainerBuilder()
.withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(
new NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME))
- .withChild(entry1).withChild(entry2).withChild(entry3).build())
- .withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1,2,3,4}))
+ .withChild(entry1).withChild(entry2).build())
+ .withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1, 2, 3, 4}))
.withChild(Builders.orderedMapBuilder()
.withNodeIdentifier(new NodeIdentifier(TestModel.ORDERED_LIST_QNAME))
.withChild(ImmutableNodes.mapEntry(TestModel.ORDERED_LIST_ENTRY_QNAME,
MockitoAnnotations.initMocks(this);
}
- private static NormalizedNodePruner prunerFullSchema(YangInstanceIdentifier path) {
+ private static NormalizedNodePruner prunerFullSchema(final YangInstanceIdentifier path) {
return new NormalizedNodePruner(path, FULL_SCHEMA);
}
- private static NormalizedNodePruner prunerNoAugSchema(YangInstanceIdentifier path) {
+ private static NormalizedNodePruner prunerNoAugSchema(final YangInstanceIdentifier path) {
return new NormalizedNodePruner(path, NO_AUG_SCHEMA);
}
- private static NormalizedNodePruner prunerNoTestSchema(YangInstanceIdentifier path) {
+ private static NormalizedNodePruner prunerNoTestSchema(final YangInstanceIdentifier path) {
return new NormalizedNodePruner(path, NO_TEST_SCHEMA);
}
}
- private static int countNodes(NormalizedNode<?,?> normalizedNode, final String namespaceFilter) {
+ private static int countNodes(final NormalizedNode<?,?> normalizedNode, final String namespaceFilter) {
if (normalizedNode == null) {
return 0;
}
}
private static NormalizedNode<?, ?> createTestContainer() {
- byte[] bytes1 = {1,2,3};
+ byte[] bytes1 = {1, 2, 3};
LeafSetEntryNode<Object> entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).withValue(bytes1).build();
LeafSetEntryNode<Object> entry2 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)).withValue(bytes2).build();
- LeafSetEntryNode<Object> entry3 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
- new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, null)).withValue(null).build();
-
-
return TestModel.createBaseTestContainerBuilder()
.withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(
new NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME))
- .withChild(entry1).withChild(entry2).withChild(entry3).build())
+ .withChild(entry1).withChild(entry2).build())
.withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1, 2, 3, 4}))
.build();
}
import java.io.InputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
-import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.List;
import java.util.Map;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public final class TestModel {
}
public static SchemaContext createTestContext() {
- List<InputStream> inputStreams = new ArrayList<>();
- inputStreams.add(getDatastoreTestInputStream());
- inputStreams.add(getDatastoreAugInputStream());
- inputStreams.add(getDatastoreTestNotificationInputStream());
-
- return resolveSchemaContext(inputStreams);
+ return YangParserTestUtils.parseYangResources(TestModel.class, DATASTORE_TEST_YANG, DATASTORE_AUG_YANG,
+ DATASTORE_TEST_NOTIFICATION_YANG);
}
public static SchemaContext createTestContextWithoutTestSchema() {
- List<InputStream> inputStreams = new ArrayList<>();
- inputStreams.add(getDatastoreTestNotificationInputStream());
-
- return resolveSchemaContext(inputStreams);
+ return YangParserTestUtils.parseYangResource(DATASTORE_TEST_NOTIFICATION_YANG);
}
-
public static SchemaContext createTestContextWithoutAugmentationSchema() {
- List<InputStream> inputStreams = new ArrayList<>();
- inputStreams.add(getDatastoreTestInputStream());
- inputStreams.add(getDatastoreTestNotificationInputStream());
-
- return resolveSchemaContext(inputStreams);
- }
-
- private static SchemaContext resolveSchemaContext(final List<InputStream> streams) {
- try {
- return YangParserTestUtils.parseYangStreams(streams);
- } catch (ReactorException e) {
- throw new RuntimeException("Unable to build schema context from " + streams, e);
- }
+ return YangParserTestUtils.parseYangResources(TestModel.class, DATASTORE_TEST_YANG,
+ DATASTORE_TEST_NOTIFICATION_YANG);
}
/**
import akka.dispatch.ExecutionContexts;
import akka.dispatch.Futures;
-import com.google.common.base.Optional;
import com.google.common.io.ByteSource;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.MoreExecutors;
import org.junit.Test;
import org.mockito.Mockito;
import org.opendaylight.controller.cluster.schema.provider.RemoteYangTextSourceProvider;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
public class RemoteSchemaProviderTest {
- private static final SourceIdentifier ID = RevisionSourceIdentifier.create("Test", Optional.of("2015-10-30"));
+ private static final SourceIdentifier ID = RevisionSourceIdentifier.create("Test", Revision.of("2015-10-30"));
private RemoteSchemaProvider remoteSchemaProvider;
private RemoteYangTextSourceProvider mockedRemoteSchemaRepository;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import com.google.common.base.Optional;
import com.google.common.io.ByteSource;
import com.google.common.util.concurrent.Futures;
import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
public class RemoteYangTextSourceProviderImplTest {
- private static final SourceIdentifier ID = RevisionSourceIdentifier.create("Test", Optional.of("2015-10-30"));
+ private static final SourceIdentifier ID = RevisionSourceIdentifier.create("Test", Revision.of("2015-10-30"));
private RemoteYangTextSourceProviderImpl remoteRepository;
private SchemaRepository mockedLocalRepository;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
-import com.google.common.base.Optional;
import com.google.common.io.ByteSource;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import org.junit.Before;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
public void setUp() {
String source = "Test source.";
schemaSource = YangTextSchemaSource.delegateForByteSource(
- RevisionSourceIdentifier.create("test", Optional.of("2015-10-30")),
+ RevisionSourceIdentifier.create("test", Revision.of("2015-10-30")),
ByteSource.wrap(source.getBytes(StandardCharsets.UTF_8)));
}
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
private static final class AugmentationNormalization extends DataContainerNormalizationOperation<AugmentationIdentifier> {
- public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) {
+ public AugmentationNormalization(final AugmentationSchemaNode augmentation, final DataNodeContainer schema) {
super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema),null);
}
final DataSchemaNode result = potential.get();
// We try to look up if this node was added by augmentation
- if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
+ if (schema instanceof DataSchemaNode && result.isAugmenting()) {
return fromAugmentation(schema, (AugmentationTarget) schema, result);
}
return fromDataSchemaNode(result);
final ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
final ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
- for (final ChoiceCaseNode caze : schema.getCases()) {
+ for (final CaseSchemaNode caze : schema.getCases().values()) {
for (final DataSchemaNode cazeChild : caze.getChildNodes()) {
final DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
byArgBuilder.put(childOp.getIdentifier(), childOp);
final DataSchemaNode result = potential.get();
// We try to look up if this node was added by augmentation
- if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
+ if (schema instanceof DataSchemaNode && result.isAugmenting()) {
return fromAugmentation(schema, (AugmentationTarget) schema, result);
}
return fromDataSchemaNode(result);
private static ChoiceSchemaNode findChoice(final Iterable<ChoiceSchemaNode> choices, final QName child) {
ChoiceSchemaNode foundChoice = null;
choiceLoop: for (final ChoiceSchemaNode choice : choices) {
- for (final ChoiceCaseNode caze : choice.getCases()) {
+ for (final CaseSchemaNode caze : choice.getCases().values()) {
if (findChildSchemaNode(caze, child).isPresent()) {
foundChoice = choice;
break choiceLoop;
return foundChoice;
}
- public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchema augmentation) {
+ public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchemaNode augmentation) {
final ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
for (final DataSchemaNode child : augmentation.getChildNodes()) {
potentialChildren.add(child.getQName());
return new AugmentationIdentifier(potentialChildren.build());
}
- private static DataNodeContainer augmentationProxy(final AugmentationSchema augmentation, final DataNodeContainer schema) {
+ private static DataNodeContainer augmentationProxy(final AugmentationSchemaNode augmentation,
+ final DataNodeContainer schema) {
final Set<DataSchemaNode> children = new HashSet<>();
for (final DataSchemaNode augNode : augmentation.getChildNodes()) {
children.add(schema.getDataChildByName(augNode.getQName()));
*/
private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
final AugmentationTarget parentAug, final DataSchemaNode child) {
- AugmentationSchema augmentation = null;
- for (final AugmentationSchema aug : parentAug.getAvailableAugmentations()) {
+ AugmentationSchemaNode augmentation = null;
+ for (final AugmentationSchemaNode aug : parentAug.getAvailableAugmentations()) {
final DataSchemaNode potential = aug.getDataChildByName(child.getQName());
if (potential != null) {
augmentation = aug;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
realChildSchemas = realChildSchema;
mappedChildSchemas = new HashMap<>();
for(DataSchemaNode schema : realChildSchemas) {
- mappedChildSchemas.put(schema.getQName(),schema);
+ mappedChildSchemas.put(schema.getQName(), schema);
}
}
@Override
- public DataSchemaNode getDataChildByName(final QName name) {
- return mappedChildSchemas.get(name);
+ public Optional<DataSchemaNode> findDataChildByName(final QName name) {
+ return Optional.ofNullable(mappedChildSchemas.get(name));
}
@Override
public Set<UsesNode> getUses() {
return Collections.emptySet();
}
-
}
@Override
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> doRead(final YangInstanceIdentifier path) {
- return Futures.immediateCheckedFuture(readOnlyView().readNode(path));
+ return Futures.immediateCheckedFuture(Optional.fromJavaUtil(readOnlyView().readNode(path)));
}
@Override
// 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 = Optional.fromJavaUtil(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 = Preconditions.checkNotNull(callback);
private ExistsTransactionSuccess handleExistsTransaction(final ExistsTransactionRequest request)
throws RequestException {
- final Optional<NormalizedNode<?, ?>> data = openTransaction.getSnapshot().readNode(request.getPath());
+ final Optional<NormalizedNode<?, ?>> data = Optional.fromJavaUtil(openTransaction.getSnapshot()
+ .readNode(request.getPath()));
return recordSuccess(request.getSequence(), new ExistsTransactionSuccess(openTransaction.getIdentifier(),
request.getSequence(), data.isPresent()));
}
private ReadTransactionSuccess handleReadTransaction(final ReadTransactionRequest request)
throws RequestException {
- final Optional<NormalizedNode<?, ?>> data = openTransaction.getSnapshot().readNode(request.getPath());
+ final Optional<NormalizedNode<?, ?>> data = Optional.fromJavaUtil(openTransaction.getSnapshot().readNode(
+ request.getPath()));
return recordSuccess(request.getSequence(), new ReadTransactionSuccess(openTransaction.getIdentifier(),
request.getSequence(), data));
}
private ExistsTransactionSuccess handleExistsTransaction(final ExistsTransactionRequest request)
throws RequestException {
- final Optional<NormalizedNode<?, ?>> data = checkOpen().getSnapshot().readNode(request.getPath());
+ final Optional<NormalizedNode<?, ?>> data = Optional.fromJavaUtil(checkOpen().getSnapshot().readNode(
+ request.getPath()));
return recordSuccess(request.getSequence(), new ExistsTransactionSuccess(getIdentifier(), request.getSequence(),
data.isPresent()));
}
private ReadTransactionSuccess handleReadTransaction(final ReadTransactionRequest request)
throws RequestException {
- final Optional<NormalizedNode<?, ?>> data = checkOpen().getSnapshot().readNode(request.getPath());
+ final Optional<NormalizedNode<?, ?>> data = Optional.fromJavaUtil(checkOpen().getSnapshot().readNode(
+ request.getPath()));
return recordSuccess(request.getSequence(), new ReadTransactionSuccess(getIdentifier(), request.getSequence(),
data));
}
import org.opendaylight.controller.cluster.raft.messages.ServerRemoved;
import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
import org.opendaylight.yangtools.concepts.Identifier;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
private DatastoreContext datastoreContext;
private SchemaContextProvider schemaContextProvider;
private DatastoreSnapshot.ShardSnapshot restoreFromSnapshot;
- private TipProducingDataTree dataTree;
+ private DataTree dataTree;
private volatile boolean sealed;
protected AbstractBuilder(final Class<S> shardClass) {
return self();
}
- public T dataTree(final TipProducingDataTree newDataTree) {
+ public T dataTree(final DataTree newDataTree) {
checkSealed();
this.dataTree = newDataTree;
return self();
return restoreFromSnapshot;
}
- public TipProducingDataTree getDataTree() {
+ public DataTree getDataTree() {
return dataTree;
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ConflictingModificationAppliedException;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateTip;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates;
+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.api.schema.tree.DataTreeSnapshot;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeTip;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTreeTip;
import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
private final ShardDataTreeChangeListenerPublisher treeChangeListenerPublisher;
private final ShardDataChangeListenerPublisher dataChangeListenerPublisher;
private final Collection<ShardDataTreeMetadata<?>> metadata;
- private final TipProducingDataTree dataTree;
+ private final DataTree dataTree;
private final String logContext;
private final Shard shard;
private Runnable runOnPendingTransactionsComplete;
/**
* Optimistic {@link DataTreeCandidate} preparation. Since our DataTree implementation is a
- * {@link TipProducingDataTree}, each {@link DataTreeCandidate} is also a {@link DataTreeTip}, e.g. another
+ * {@link DataTree}, each {@link DataTreeCandidate} is also a {@link DataTreeTip}, e.g. another
* candidate can be prepared on top of it. They still need to be committed in sequence. Here we track the current
* tip of the data tree, which is the last DataTreeCandidate we have in flight, or the DataTree itself.
*/
- private TipProducingDataTreeTip tip;
+ private DataTreeTip tip;
private SchemaContext schemaContext;
private int currentTransactionBatch;
- ShardDataTree(final Shard shard, final SchemaContext schemaContext, final TipProducingDataTree dataTree,
+ ShardDataTree(final Shard shard, final SchemaContext schemaContext, final DataTree dataTree,
final ShardDataTreeChangeListenerPublisher treeChangeListenerPublisher,
final ShardDataChangeListenerPublisher dataChangeListenerPublisher, final String logContext,
final ShardDataTreeMetadata<?>... metadata) {
final ShardDataTreeChangeListenerPublisher treeChangeListenerPublisher,
final ShardDataChangeListenerPublisher dataChangeListenerPublisher, final String logContext,
final ShardDataTreeMetadata<?>... metadata) {
- this(shard, schemaContext, InMemoryDataTreeFactory.getInstance().create(treeType, root),
- treeChangeListenerPublisher, dataChangeListenerPublisher, logContext, metadata);
+ this(shard, schemaContext, createDataTree(treeType, root), treeChangeListenerPublisher,
+ dataChangeListenerPublisher, logContext, metadata);
+ }
+
+ private static DataTree createDataTree(final TreeType treeType, final YangInstanceIdentifier root) {
+ final DataTreeConfiguration baseConfig = DataTreeConfiguration.getDefault(treeType);
+ return new InMemoryDataTreeFactory().create(new DataTreeConfiguration.Builder(baseConfig.getTreeType())
+ .setMandatoryNodesValidation(baseConfig.isMandatoryNodesValidationEnabled())
+ .setUniqueIndexes(baseConfig.isUniqueIndexEnabled())
+ .setRootPath(root)
+ .build());
}
@VisibleForTesting
return shard.ticker().read();
}
- public TipProducingDataTree getDataTree() {
+ public DataTree getDataTree() {
return dataTree;
}
}
Optional<DataTreeCandidate> readCurrentData() {
- final Optional<NormalizedNode<?, ?>> currentState =
+ final java.util.Optional<NormalizedNode<?, ?>> currentState =
dataTree.takeSnapshot().readNode(YangInstanceIdentifier.EMPTY);
return currentState.isPresent() ? Optional.of(DataTreeCandidates.fromNormalizedNode(
YangInstanceIdentifier.EMPTY, currentState.get())) : Optional.<DataTreeCandidate>absent();
}
public Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier path) {
- return dataTree.takeSnapshot().readNode(path);
+ return Optional.fromJavaUtil(dataTree.takeSnapshot().readNode(path));
}
DataTreeSnapshot takeSnapshot() {
return false;
}
- TipProducingDataTreeTip newTip = MoreObjects.firstNonNull(first.cohort.getCandidate(), dataTree);
+ DataTreeTip newTip = MoreObjects.firstNonNull(first.cohort.getCandidate(), dataTree);
while (it.hasNext()) {
final CommitEntry e = it.next();
if (cohort.equals(e.cohort)) {
}
@SuppressWarnings("checkstyle:IllegalCatch")
- private void rebaseTransactions(final Iterator<CommitEntry> iter, @Nonnull final TipProducingDataTreeTip newTip) {
+ private void rebaseTransactions(final Iterator<CommitEntry> iter, @Nonnull final DataTreeTip newTip) {
tip = Preconditions.checkNotNull(newTip);
while (iter.hasNext()) {
final SimpleShardDataTreeCohort cohort = iter.next().cohort;
import akka.actor.Props;
import akka.actor.ReceiveTimeout;
import akka.japi.Creator;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* The ShardTransaction Actor represents a remote transaction that delegates all actions to DOMDataReadWriteTransaction.
}
final YangInstanceIdentifier path = message.getPath();
- Optional<NormalizedNode<?, ?>> optional = transaction.getSnapshot().readNode(path);
- ReadDataReply readDataReply = new ReadDataReply(optional.orNull(), message.getVersion());
+ ReadDataReply readDataReply = new ReadDataReply(transaction.getSnapshot().readNode(path).orElse(null),
+ message.getVersion());
sender().tell(readDataReply.toSerializable(), self());
}
.node(EntityType.QNAME).node(EntityType.QNAME).node(ENTITY_QNAME).node(ENTITY_QNAME)
.node(ENTITY_OWNER_QNAME).build();
- void init(ShardDataTree shardDataTree) {
+ void init(final ShardDataTree shardDataTree) {
shardDataTree.registerTreeChangeListener(EOS_PATH, this, Optional.absent(), noop -> { /* NOOP */ });
}
- protected static String extractOwner(LeafNode<?> ownerLeaf) {
- Object value = ownerLeaf.getValue();
- return value != null ? value.toString() : null;
+ protected static String extractOwner(final LeafNode<?> ownerLeaf) {
+ return ownerLeaf.getValue().toString();
}
}
implements DOMEntityOwnershipCandidateRegistration {
private final DistributedEntityOwnershipService service;
- DistributedEntityOwnershipCandidateRegistration(DOMEntity entity, DistributedEntityOwnershipService service) {
+ DistributedEntityOwnershipCandidateRegistration(final DOMEntity entity,
+ final DistributedEntityOwnershipService service) {
super(entity);
this.service = service;
}
protected void removeRegistration() {
service.unregisterCandidate(getInstance());
}
-
- @Override
- public String toString() {
- return "DistributedEntityOwnershipCandidateRegistration [entity=" + getInstance() + "]";
- }
-
-
}
*/
package org.opendaylight.controller.cluster.datastore.entityownership;
+import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.base.Preconditions;
import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListener;
import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListenerRegistration;
private final DistributedEntityOwnershipService service;
private final String entityType;
- DistributedEntityOwnershipListenerRegistration(DOMEntityOwnershipListener listener, String entityType,
- DistributedEntityOwnershipService service) {
+ DistributedEntityOwnershipListenerRegistration(final DOMEntityOwnershipListener listener, final String entityType,
+ final DistributedEntityOwnershipService service) {
super(listener);
this.entityType = Preconditions.checkNotNull(entityType, "entityType cannot be null");
this.service = Preconditions.checkNotNull(service, "DOMEntityOwnershipListener cannot be null");
}
@Override
- public String toString() {
- return "DistributedEntityOwnershipListenerRegistration [entityType=" + getEntityType()
- + ", listener=" + getInstance() + "]";
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return toStringHelper.add("entityType", entityType);
}
}
return Optional.absent();
}
- Optional<NormalizedNode<?, ?>> entityNode = dataTree.takeSnapshot().readNode(
+ java.util.Optional<NormalizedNode<?, ?>> entityNode = dataTree.takeSnapshot().readNode(
entityPath(forEntity.getType(), forEntity.getIdentifier()));
if (!entityNode.isPresent()) {
return Optional.absent();
// 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 =
+ final java.util.Optional<DataContainerChild<? extends PathArgument, ?>> optionalCandidates =
entity.getChild(CANDIDATE_NODE_ID);
final boolean hasCandidates = optionalCandidates.isPresent()
&& ((MapNode) optionalCandidates.get()).getValue().size() > 0;
}
MemberName localMemberName = context.getCurrentMemberName();
- Optional<DataContainerChild<? extends PathArgument, ?>> ownerLeaf = entity.getChild(ENTITY_OWNER_NODE_ID);
+ java.util.Optional<DataContainerChild<? extends PathArgument, ?>> ownerLeaf = entity.getChild(
+ ENTITY_OWNER_NODE_ID);
String owner = ownerLeaf.isPresent() ? ownerLeaf.get().getValue().toString() : null;
boolean hasOwner = !Strings.isNullOrEmpty(owner);
boolean isOwner = hasOwner && localMemberName.getName().equals(owner);
import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.createEntity;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.base.Verify;
import java.util.Collection;
import java.util.Objects;
+import java.util.Optional;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
private EntityOwnersModel() {
}
- static YangInstanceIdentifier entityPath(String entityType, YangInstanceIdentifier entityId) {
+ static YangInstanceIdentifier entityPath(final String entityType, final YangInstanceIdentifier entityId) {
return YangInstanceIdentifier.builder(ENTITY_OWNERS_PATH).node(EntityType.QNAME)
.nodeWithKey(EntityType.QNAME, ENTITY_TYPE_QNAME, entityType).node(ENTITY_QNAME)
.nodeWithKey(ENTITY_QNAME, ENTITY_ID_QNAME, entityId).build();
}
- static YangInstanceIdentifier candidatePath(String entityType, YangInstanceIdentifier entityId,
- String candidateName) {
+ static YangInstanceIdentifier candidatePath(final String entityType, final YangInstanceIdentifier entityId,
+ final String candidateName) {
return YangInstanceIdentifier.builder(ENTITY_OWNERS_PATH).node(EntityType.QNAME)
.nodeWithKey(EntityType.QNAME, ENTITY_TYPE_QNAME, entityType).node(ENTITY_QNAME)
.nodeWithKey(ENTITY_QNAME, ENTITY_ID_QNAME, entityId).node(Candidate.QNAME)
}
- static YangInstanceIdentifier candidatePath(YangInstanceIdentifier entityPath, String candidateName) {
+ static YangInstanceIdentifier candidatePath(final YangInstanceIdentifier entityPath, final String candidateName) {
return YangInstanceIdentifier.builder(entityPath).node(Candidate.QNAME).nodeWithKey(
Candidate.QNAME, CANDIDATE_NAME_QNAME, candidateName).build();
}
- static NodeIdentifierWithPredicates candidateNodeKey(String candidateName) {
+ static NodeIdentifierWithPredicates candidateNodeKey(final String candidateName) {
return new NodeIdentifierWithPredicates(Candidate.QNAME, CANDIDATE_NAME_QNAME, candidateName);
}
- static NormalizedNode<?, ?> entityOwnersWithCandidate(String entityType, YangInstanceIdentifier entityId,
- String candidateName) {
+ static NormalizedNode<?, ?> entityOwnersWithCandidate(final String entityType,
+ final YangInstanceIdentifier entityId, final String candidateName) {
return entityOwnersWithEntityTypeEntry(entityTypeEntryWithEntityEntry(entityType,
entityEntryWithCandidateEntry(entityId, candidateName)));
}
- static ContainerNode entityOwnersWithEntityTypeEntry(MapEntryNode entityTypeNode) {
+ static ContainerNode entityOwnersWithEntityTypeEntry(final MapEntryNode entityTypeNode) {
return ImmutableContainerNodeBuilder.create().withNodeIdentifier(
ENTITY_OWNERS_NODE_ID).addChild(ImmutableNodes.mapNodeBuilder(EntityType.QNAME)
.addChild(entityTypeNode).build()).build();
}
- static MapEntryNode entityTypeEntryWithEntityEntry(String entityType, MapEntryNode entityNode) {
+ static MapEntryNode entityTypeEntryWithEntityEntry(final String entityType, final MapEntryNode entityNode) {
return ImmutableNodes.mapEntryBuilder(EntityType.QNAME,
ENTITY_TYPE_QNAME, entityType).addChild(ImmutableNodes.mapNodeBuilder(
ENTITY_QNAME).addChild(entityNode).build()).build();
}
- static MapEntryNode entityEntryWithCandidateEntry(YangInstanceIdentifier entityId, String candidateName) {
+ static MapEntryNode entityEntryWithCandidateEntry(final YangInstanceIdentifier entityId,
+ final String candidateName) {
return ImmutableNodes.mapEntryBuilder(ENTITY_QNAME, ENTITY_ID_QNAME, entityId).addChild(
candidateEntry(candidateName)).build();
}
- static MapNode candidateEntry(String candidateName) {
+ static MapNode candidateEntry(final String candidateName) {
return ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(Candidate.QNAME))
.addChild(candidateMapEntry(candidateName)).build();
}
- static MapEntryNode candidateMapEntry(String candidateName) {
+ static MapEntryNode candidateMapEntry(final String candidateName) {
return ImmutableNodes.mapEntry(Candidate.QNAME, CANDIDATE_NAME_QNAME, candidateName);
}
- static MapEntryNode entityEntryWithOwner(YangInstanceIdentifier entityId, String owner) {
- return ImmutableNodes.mapEntryBuilder(ENTITY_QNAME, ENTITY_ID_QNAME, entityId).addChild(
- ImmutableNodes.leafNode(ENTITY_OWNER_QNAME, owner)).build();
+ static MapEntryNode entityEntryWithOwner(final YangInstanceIdentifier entityId, final String owner) {
+ return ImmutableNodes.mapEntryBuilder(ENTITY_QNAME, ENTITY_ID_QNAME, entityId)
+ .addChild(ImmutableNodes.leafNode(ENTITY_OWNER_QNAME, owner != null ? owner : ""))
+ .build();
}
- public static String entityTypeFromEntityPath(YangInstanceIdentifier entityPath) {
+ public static String entityTypeFromEntityPath(final YangInstanceIdentifier entityPath) {
YangInstanceIdentifier parent = entityPath;
while (!parent.isEmpty()) {
if (EntityType.QNAME.equals(parent.getLastPathArgument().getNodeType())) {
return null;
}
- static DOMEntity createEntity(YangInstanceIdentifier entityPath) {
+ static DOMEntity createEntity(final YangInstanceIdentifier entityPath) {
String entityType = null;
YangInstanceIdentifier entityId = null;
for (PathArgument pathArg: entityPath.getPathArguments()) {
getSender().tell(SuccessReply.INSTANCE, getSelf());
searchForEntities((entityTypeNode, entityNode) -> {
- Optional<DataContainerChild<?, ?>> possibleType = entityTypeNode.getChild(ENTITY_TYPE_NODE_ID);
+ java.util.Optional<DataContainerChild<?, ?>> possibleType = entityTypeNode.getChild(ENTITY_TYPE_NODE_ID);
String entityType = possibleType.isPresent() ? possibleType.get().getValue().toString() : null;
if (registerListener.getEntityType().equals(entityType)) {
final boolean hasOwner;
final boolean isOwner;
- Optional<DataContainerChild<?, ?>> possibleOwner = entityNode.getChild(ENTITY_OWNER_NODE_ID);
+ java.util.Optional<DataContainerChild<?, ?>> possibleOwner = entityNode.getChild(ENTITY_OWNER_NODE_ID);
if (possibleOwner.isPresent()) {
isOwner = localMemberName.getName().equals(possibleOwner.get().getValue().toString());
hasOwner = true;
private void notifyAllListeners() {
searchForEntities((entityTypeNode, entityNode) -> {
- Optional<DataContainerChild<?, ?>> possibleType = entityTypeNode.getChild(ENTITY_TYPE_NODE_ID);
+ java.util.Optional<DataContainerChild<?, ?>> possibleType = entityTypeNode.getChild(ENTITY_TYPE_NODE_ID);
if (possibleType.isPresent()) {
final boolean hasOwner;
final boolean isOwner;
- Optional<DataContainerChild<?, ?>> possibleOwner = entityNode.getChild(ENTITY_OWNER_NODE_ID);
+ java.util.Optional<DataContainerChild<?, ?>> possibleOwner = entityNode.getChild(ENTITY_OWNER_NODE_ID);
if (possibleOwner.isPresent()) {
isOwner = localMemberName.getName().equals(possibleOwner.get().getValue().toString());
hasOwner = true;
.node(entityTypeNode.getIdentifier()).node(ENTITY_NODE_ID).node(entityNode.getIdentifier())
.node(ENTITY_OWNER_NODE_ID).build();
- Optional<String> possibleOwner = entityNode.getChild(ENTITY_OWNER_NODE_ID).transform(
- node -> node.getValue().toString());
- String newOwner = newOwner(possibleOwner.orNull(), getCandidateNames(entityNode),
+ java.util.Optional<String> possibleOwner =
+ entityNode.getChild(ENTITY_OWNER_NODE_ID).map(node -> node.getValue().toString());
+ String newOwner = newOwner(possibleOwner.orElse(null), getCandidateNames(entityNode),
getEntityOwnerElectionStrategy(entityPath));
- if (!newOwner.equals(possibleOwner.or(""))) {
+ if (!newOwner.equals(possibleOwner.orElse(""))) {
modifications.add(new WriteModification(entityPath,
ImmutableNodes.leafNode(ENTITY_OWNER_NODE_ID, newOwner)));
}
LOG.debug("{}: Searching for entities owned by {}", persistenceId(), ownedBy);
searchForEntities((entityTypeNode, entityNode) -> {
- Optional<DataContainerChild<? extends PathArgument, ?>> possibleOwner =
+ java.util.Optional<DataContainerChild<? extends PathArgument, ?>> possibleOwner =
entityNode.getChild(ENTITY_OWNER_NODE_ID);
String currentOwner = possibleOwner.isPresent() ? possibleOwner.get().getValue().toString() : "";
if (ownedBy.contains(currentOwner)) {
}
for (MapEntryNode entityType: ((MapNode) possibleEntityTypes.get()).getValue()) {
- Optional<DataContainerChild<?, ?>> possibleEntities = entityType.getChild(ENTITY_NODE_ID);
+ java.util.Optional<DataContainerChild<?, ?>> possibleEntities = entityType.getChild(ENTITY_NODE_ID);
if (!possibleEntities.isPresent()) {
// shouldn't happen but handle anyway
continue;
import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.entityTypeFromEntityPath;
-import com.google.common.base.Optional;
import com.google.common.base.Strings;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.triemap.TrieMap;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import com.google.common.base.Optional;
import java.util.Collection;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
@Override
public final Optional<NormalizedNode<?, ?>> getDataAfter() {
- return Optional.absent();
+ return Optional.empty();
}
@Override
*/
package org.opendaylight.controller.cluster.datastore.persisted;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
private void updateSchemaContext(final Object message) {
schemaContext = ((UpdateSchemaContext) message).getSchemaContext();
- LOG.debug("Got updated SchemaContext: # of modules {}", schemaContext.getAllModuleIdentifiers().size());
+ LOG.debug("Got updated SchemaContext: # of modules {}", schemaContext.getModules().size());
for (ShardInformation info : localShards.values()) {
info.setSchemaContext(schemaContext);
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
+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.api.schema.tree.DataValidationFailedException;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
private NormalizedNodeAggregator(final YangInstanceIdentifier rootIdentifier,
final List<Optional<NormalizedNode<?, ?>>> nodes, final SchemaContext schemaContext,
- LogicalDatastoreType logicalDatastoreType) {
+ final LogicalDatastoreType logicalDatastoreType) {
this.rootIdentifier = rootIdentifier;
this.nodes = nodes;
- this.dataTree = InMemoryDataTreeFactory.getInstance().create(
- logicalDatastoreType == LogicalDatastoreType.CONFIGURATION ? TreeType.CONFIGURATION :
- TreeType.OPERATIONAL);
+ this.dataTree = new InMemoryDataTreeFactory().create(
+ logicalDatastoreType == LogicalDatastoreType.CONFIGURATION ? DataTreeConfiguration.DEFAULT_CONFIGURATION
+ : DataTreeConfiguration.DEFAULT_OPERATIONAL);
this.dataTree.setSchemaContext(schemaContext);
}
*/
public static Optional<NormalizedNode<?,?>> aggregate(final YangInstanceIdentifier rootIdentifier,
final List<Optional<NormalizedNode<?, ?>>> nodes, final SchemaContext schemaContext,
- LogicalDatastoreType logicalDatastoreType) throws DataValidationFailedException {
+ final LogicalDatastoreType logicalDatastoreType) throws DataValidationFailedException {
return new NormalizedNodeAggregator(rootIdentifier, nodes, schemaContext, logicalDatastoreType).aggregate();
}
}
private Optional<NormalizedNode<?, ?>> getRootNode() {
- return dataTree.takeSnapshot().readNode(rootIdentifier);
+ return Optional.fromJavaUtil(dataTree.takeSnapshot().readNode(rootIdentifier));
}
}
package org.opendaylight.controller.cluster.datastore.utils;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ForwardingObject;
import java.io.IOException;
+import java.util.Optional;
import org.opendaylight.controller.cluster.datastore.node.utils.transformer.NormalizedNodePruner;
import org.opendaylight.controller.cluster.datastore.util.AbstractDataTreeModificationCursor;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
private final SchemaContext schemaContext;
private final DataTree dataTree;
- public PruningDataTreeModification(DataTreeModification delegate, DataTree dataTree, SchemaContext schemaContext) {
+ public PruningDataTreeModification(final DataTreeModification delegate, final DataTree dataTree,
+ final SchemaContext schemaContext) {
this.delegate = Preconditions.checkNotNull(delegate);
this.dataTree = Preconditions.checkNotNull(dataTree);
this.schemaContext = Preconditions.checkNotNull(schemaContext);
}
@Override
- public void delete(YangInstanceIdentifier yangInstanceIdentifier) {
+ public void delete(final YangInstanceIdentifier yangInstanceIdentifier) {
try {
delegate.delete(yangInstanceIdentifier);
} catch (SchemaValidationFailedException e) {
}
@Override
- public void merge(YangInstanceIdentifier yangInstanceIdentifier, NormalizedNode<?, ?> normalizedNode) {
+ public void merge(final YangInstanceIdentifier yangInstanceIdentifier, final NormalizedNode<?, ?> normalizedNode) {
try {
if (YangInstanceIdentifier.EMPTY.equals(yangInstanceIdentifier)) {
pruneAndMergeNode(yangInstanceIdentifier, normalizedNode);
}
- private void pruneAndMergeNode(YangInstanceIdentifier yangInstanceIdentifier, NormalizedNode<?, ?> normalizedNode) {
+ private void pruneAndMergeNode(final YangInstanceIdentifier yangInstanceIdentifier,
+ final NormalizedNode<?, ?> normalizedNode) {
NormalizedNode<?,?> pruned = pruneNormalizedNode(yangInstanceIdentifier, normalizedNode);
if (pruned != null) {
}
@Override
- public void write(YangInstanceIdentifier yangInstanceIdentifier, NormalizedNode<?, ?> normalizedNode) {
+ public void write(final YangInstanceIdentifier yangInstanceIdentifier, final NormalizedNode<?, ?> normalizedNode) {
try {
if (YangInstanceIdentifier.EMPTY.equals(yangInstanceIdentifier)) {
pruneAndWriteNode(yangInstanceIdentifier, normalizedNode);
}
}
- private void pruneAndWriteNode(YangInstanceIdentifier yangInstanceIdentifier, NormalizedNode<?, ?> normalizedNode) {
+ private void pruneAndWriteNode(final YangInstanceIdentifier yangInstanceIdentifier,
+ final NormalizedNode<?, ?> normalizedNode) {
NormalizedNode<?,?> pruned = pruneNormalizedNode(yangInstanceIdentifier, normalizedNode);
if (pruned != null) {
}
@Override
- public void applyToCursor(DataTreeModificationCursor dataTreeModificationCursor) {
+ public void applyToCursor(final DataTreeModificationCursor dataTreeModificationCursor) {
delegate.applyToCursor(dataTreeModificationCursor);
}
@Override
- public Optional<NormalizedNode<?, ?>> readNode(YangInstanceIdentifier yangInstanceIdentifier) {
+ public Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier yangInstanceIdentifier) {
return delegate.readNode(yangInstanceIdentifier);
}
}
@VisibleForTesting
- NormalizedNode<?, ?> pruneNormalizedNode(YangInstanceIdentifier path, NormalizedNode<?,?> input) {
+ NormalizedNode<?, ?> pruneNormalizedNode(final YangInstanceIdentifier path, final NormalizedNode<?,?> input) {
NormalizedNodePruner pruner = new NormalizedNodePruner(path, schemaContext);
try {
NormalizedNodeWriter.forStreamWriter(pruner).write(input);
private final DataTreeModification toModification;
private final PruningDataTreeModification pruningModification;
- PruningDataTreeModificationCursor(DataTreeModification toModification,
- PruningDataTreeModification pruningModification) {
+ PruningDataTreeModificationCursor(final DataTreeModification toModification,
+ final PruningDataTreeModification pruningModification) {
this.toModification = toModification;
this.pruningModification = pruningModification;
}
@Override
- public void write(PathArgument child, NormalizedNode<?, ?> data) {
+ public void write(final PathArgument child, final NormalizedNode<?, ?> data) {
YangInstanceIdentifier path = current().node(child);
NormalizedNode<?, ?> prunedNode = pruningModification.pruneNormalizedNode(path, data);
if (prunedNode != null) {
}
@Override
- public void merge(PathArgument child, NormalizedNode<?, ?> data) {
+ public void merge(final PathArgument child, final NormalizedNode<?, ?> data) {
YangInstanceIdentifier path = current().node(child);
NormalizedNode<?, ?> prunedNode = pruningModification.pruneNormalizedNode(path, data);
if (prunedNode != null) {
}
@Override
- public void delete(PathArgument child) {
+ public void delete(final PathArgument child) {
try {
toModification.delete(current().node(child));
} catch (SchemaValidationFailedException e) {
package org.opendaylight.controller.cluster.sharding;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates;
+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.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.SchemaValidationFailedException;
import org.slf4j.Logger;
// TODO keeping the whole dataTree thats contained in subshards doesn't seem like a good idea
// maybe the whole listener logic would be better in the backend shards where we have direct access to the
// dataTree and wont have to cache it redundantly.
- this.dataTree = InMemoryDataTreeFactory.getInstance().create(
- TreeType.valueOf(prefix.getDatastoreType().name()), prefix.getRootIdentifier());
- dataTree.setSchemaContext(distributedDataStore.getActorContext().getSchemaContext());
+ final DataTreeConfiguration baseConfig;
+ switch (prefix.getDatastoreType()) {
+ case CONFIGURATION:
+ baseConfig = DataTreeConfiguration.DEFAULT_CONFIGURATION;
+ break;
+ case OPERATIONAL:
+ baseConfig = DataTreeConfiguration.DEFAULT_OPERATIONAL;
+ break;
+ default:
+ throw new UnsupportedOperationException("Unknown prefix type " + prefix.getDatastoreType());
+ }
+
+ this.dataTree = new InMemoryDataTreeFactory().create(new DataTreeConfiguration.Builder(baseConfig.getTreeType())
+ .setMandatoryNodesValidation(baseConfig.isMandatoryNodesValidationEnabled())
+ .setUniqueIndexes(baseConfig.isUniqueIndexEnabled())
+ .setRootPath(prefix.getRootIdentifier())
+ .build());
+ // XXX: can we guarantee that the root is present in the schemacontext?
+ this.dataTree.setSchemaContext(distributedDataStore.getActorContext().getSchemaContext());
this.shardPath = prefix.getRootIdentifier();
this.childShards = childShards;
}
@Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataAfter() {
- return Optional.absent();
+ return Optional.empty();
}
@Nonnull
@Override
public Optional<NormalizedNode<?, ?>> getDataBefore() {
- return Optional.absent();
+ return Optional.empty();
}
}
}
package org.opendaylight.controller.cluster.sharding;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.AsyncFunction;
import com.google.common.util.concurrent.FutureCallback;
import java.util.Collection;
import java.util.List;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientTransaction;
<argument value="${max-data-broker-future-callback-pool-size}"/>
<argument value="${max-data-broker-future-callback-queue-size}"/>
<argument value="CommitFutures"/>
+ <argument>
+ <!-- We should use a more specific class -->
+ <bean factory-ref="operDatastore" factory-method="getClass"/>
+ </argument>
</bean>
<bean id="commitStatsTracker" class="org.opendaylight.yangtools.util.DurationStatisticsTracker"
import akka.testkit.JavaTestKit;
import akka.testkit.TestProbe;
import java.util.Collections;
+import java.util.Optional;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
public void testGetConnection() throws Exception {
//set up data tree mock
final CursorAwareDataTreeModification modification = mock(CursorAwareDataTreeModification.class);
- when(modification.readNode(YangInstanceIdentifier.EMPTY)).thenReturn(com.google.common.base.Optional.absent());
+ when(modification.readNode(YangInstanceIdentifier.EMPTY)).thenReturn(Optional.empty());
final DataTreeSnapshot snapshot = mock(DataTreeSnapshot.class);
when(snapshot.newModification()).thenReturn(modification);
final DataTree dataTree = mock(DataTree.class);
@Override
public void setUp() throws Exception {
super.setUp();
- when(getDataTreeSnapshot().readNode(PATH)).thenReturn(Optional.absent());
+ when(getDataTreeSnapshot().readNode(PATH)).thenReturn(java.util.Optional.empty());
}
@Override
public void setUp() throws Exception {
super.setUp();
when(getDataTreeSnapshot().newModification()).thenReturn(modification);
- when(modification.readNode(PATH)).thenReturn(Optional.of(DATA));
+ when(modification.readNode(PATH)).thenReturn(java.util.Optional.of(DATA));
}
@Override
import akka.testkit.TestProbe;
import com.google.common.base.Ticker;
import com.google.common.base.VerifyException;
+import java.util.Optional;
import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.controller.cluster.access.commands.AbortLocalTransactionRequest;
protected LocalReadOnlyProxyTransaction createTransaction(final ProxyHistory parent,
final TransactionIdentifier id,
final DataTreeSnapshot snapshot) {
- when(snapshot.readNode(PATH_1)).thenReturn(com.google.common.base.Optional.of(DATA_1));
- when(snapshot.readNode(PATH_3)).thenReturn(com.google.common.base.Optional.absent());
+ when(snapshot.readNode(PATH_1)).thenReturn(Optional.of(DATA_1));
+ when(snapshot.readNode(PATH_3)).thenReturn(Optional.empty());
this.snapshot = snapshot;
return new LocalReadOnlyProxyTransaction(parent, id, this.snapshot);
}
import akka.testkit.TestProbe;
import com.google.common.base.Ticker;
import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Optional;
import java.util.function.Consumer;
import org.junit.Assert;
import org.junit.Test;
final TransactionIdentifier id,
final DataTreeSnapshot snapshot) {
when(snapshot.newModification()).thenReturn(modification);
- when(modification.readNode(PATH_1)).thenReturn(com.google.common.base.Optional.of(DATA_1));
- when(modification.readNode(PATH_3)).thenReturn(com.google.common.base.Optional.absent());
+ when(modification.readNode(PATH_1)).thenReturn(Optional.of(DATA_1));
+ when(modification.readNode(PATH_3)).thenReturn(Optional.empty());
return new LocalReadWriteProxyTransaction(parent, TestUtils.TRANSACTION_ID, snapshot);
}
import akka.pattern.Patterns;
import akka.testkit.TestActorRef;
import akka.util.Timeout;
-import com.google.common.base.Optional;
import com.google.common.primitives.UnsignedLong;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Uninterruptibles;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateTip;
+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.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
Assert.fail(String.format("Expected last applied: %d, Actual: %d", expectedValue, lastApplied));
}
- protected TipProducingDataTree createDelegatingMockDataTree() throws Exception {
- TipProducingDataTree actual = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
- final TipProducingDataTree mock = mock(TipProducingDataTree.class);
+ protected DataTree createDelegatingMockDataTree() throws Exception {
+ final DataTree actual = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_CONFIGURATION);
+ final DataTree mock = mock(DataTree.class);
doAnswer(invocation -> {
actual.validate(invocation.getArgumentAt(0, DataTreeModification.class));
}
public static NormalizedNode<?,?> readStore(final DataTree store, final YangInstanceIdentifier id) {
- return store.takeSnapshot().readNode(id).orNull();
+ return store.takeSnapshot().readNode(id).orElse(null);
}
public void writeToStore(final TestActorRef<Shard> shard, final YangInstanceIdentifier id,
}
DataTree setupInMemorySnapshotStore() throws DataValidationFailedException {
- final DataTree testStore = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- testStore.setSchemaContext(SCHEMA_CONTEXT);
+ final DataTree testStore = new InMemoryDataTreeFactory().create(
+ DataTreeConfiguration.DEFAULT_OPERATIONAL, SCHEMA_CONTEXT);
writeToStore(testStore, TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_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.schema.tree.DataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
-
/**
* Unit tests for DatastoreSnapshotRestore.
*
assertNull("Expected null DatastoreSnapshot", instance.getAndRemove("oper"));
}
- private static void assertDatastoreSnapshotEquals(DatastoreSnapshot expected, DatastoreSnapshot actual) {
+ private static void assertDatastoreSnapshotEquals(final DatastoreSnapshot expected,
+ final DatastoreSnapshot actual) {
assertNotNull("DatastoreSnapshot is null", actual);
assertEquals("getType", expected.getType(), actual.getType());
}
}
- private static void assertSnapshotEquals(String prefix, Snapshot expected, Snapshot actual) {
+ private static void assertSnapshotEquals(final String prefix, final Snapshot expected, final Snapshot actual) {
assertEquals(prefix + " lastIndex", expected.getLastIndex(), actual.getLastIndex());
assertEquals(prefix + " lastTerm", expected.getLastTerm(), actual.getLastTerm());
assertEquals(prefix + " lastAppliedIndex", expected.getLastAppliedIndex(), actual.getLastAppliedIndex());
((ShardSnapshotState)actual.getState()).getSnapshot().getRootNode());
}
- private static ShardManagerSnapshot newShardManagerSnapshot(String... shards) {
+ private static ShardManagerSnapshot newShardManagerSnapshot(final String... shards) {
return new ShardManagerSnapshot(Arrays.asList(shards), Collections.emptyMap());
}
- private static Snapshot newSnapshot(YangInstanceIdentifier path, NormalizedNode<?, ?> node)
+ private static Snapshot newSnapshot(final YangInstanceIdentifier path, final NormalizedNode<?, ?> node)
throws Exception {
- DataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- dataTree.setSchemaContext(SchemaContextHelper.full());
+ DataTree dataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_OPERATIONAL,
+ SchemaContextHelper.full());
AbstractShardTest.writeToStore(dataTree, path, node);
NormalizedNode<?, ?> root = AbstractShardTest.readStore(dataTree, YangInstanceIdentifier.EMPTY);
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.tree.DataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
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.tree.InMemoryDataTreeFactory;
CarsModel.newCarsMapNode(CarsModel.newCarEntry("optima", BigInteger.valueOf(20000L)),
CarsModel.newCarEntry("sportage", BigInteger.valueOf(30000L))));
- DataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- dataTree.setSchemaContext(SchemaContextHelper.full());
+ DataTree dataTree = new InMemoryDataTreeFactory().create(
+ DataTreeConfiguration.DEFAULT_OPERATIONAL, SchemaContextHelper.full());
AbstractShardTest.writeToStore(dataTree, CarsModel.BASE_PATH, carsNode);
NormalizedNode<?, ?> root = AbstractShardTest.readStore(dataTree, YangInstanceIdentifier.EMPTY);
new ShardSnapshotState(new MetadataShardDataTreeSnapshot(root)),
Collections.emptyList(), 2, 1, 2, 1, 1, "member-1", null);
- dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- dataTree.setSchemaContext(SchemaContextHelper.full());
+ dataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_OPERATIONAL,
+ SchemaContextHelper.full());
final NormalizedNode<?, ?> peopleNode = PeopleModel.create();
AbstractShardTest.writeToStore(dataTree, PeopleModel.BASE_PATH, peopleNode);
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.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.api.schema.tree.TipProducingDataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
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;
.findLocalShard("cars");
assertEquals("Cars follower shard found", true, carsFollowerShard.isPresent());
- final TipProducingDataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- dataTree.setSchemaContext(SchemaContextHelper.full());
+ final DataTree dataTree = new InMemoryDataTreeFactory().create(
+ DataTreeConfiguration.DEFAULT_OPERATIONAL, SchemaContextHelper.full());
// Send a tx with immediate commit.
// Setup a saved snapshot on the leader. The follower will startup with no data and the leader should
// install a snapshot to sync the follower.
- TipProducingDataTree tree = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
- tree.setSchemaContext(SchemaContextHelper.full());
+ DataTree tree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_CONFIGURATION,
+ SchemaContextHelper.full());
final ContainerNode carsNode = CarsModel.newCarsNode(
CarsModel.newCarsMapNode(CarsModel.newCarEntry("optima", BigInteger.valueOf(20000))));
import static org.opendaylight.controller.cluster.datastore.ShardDataTreeMocking.immediatePayloadReplication;
import static org.opendaylight.controller.cluster.datastore.ShardDataTreeMocking.immediatePreCommit;
-import com.google.common.base.Optional;
import com.google.common.base.Ticker;
import com.google.common.collect.Maps;
import com.google.common.primitives.UnsignedLong;
import java.util.Collection;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
import org.junit.Before;
DOMDataTreeChangeListener listener = mock(DOMDataTreeChangeListener.class);
shardDataTree.registerTreeChangeListener(CarsModel.CAR_LIST_PATH.node(CarsModel.CAR_QNAME), listener,
- Optional.absent(), noop -> { });
+ com.google.common.base.Optional.absent(), noop -> { });
addCar(shardDataTree, "optima");
import org.opendaylight.controller.md.cluster.datastore.model.SchemaContextHelper;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateTip;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
+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.api.schema.tree.DataTreeSnapshot;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.SchemaValidationFailedException;
}
}
- private DataTreeCandidateTip createCar() {
- final TipProducingDataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- dataTree.setSchemaContext(carsSchemaContext);
+ private DataTreeCandidate createCar() {
+ final DataTree dataTree = new InMemoryDataTreeFactory().create(
+ DataTreeConfiguration.DEFAULT_OPERATIONAL, carsSchemaContext);
final DataTreeSnapshot snapshot = dataTree.takeSnapshot();
}
private Optional<NormalizedNode<?,?>> readCars(final ShardDataTree shardDataTree) {
- final TipProducingDataTree dataTree = shardDataTree.getDataTree();
+ final DataTree dataTree = shardDataTree.getDataTree();
// FIXME: this should not be called here
dataTree.setSchemaContext(peopleSchemaContext);
}
private Optional<NormalizedNode<?,?>> readPeople(final ShardDataTree shardDataTree) {
- final TipProducingDataTree dataTree = shardDataTree.getDataTree();
+ final DataTree dataTree = shardDataTree.getDataTree();
// FIXME: this should not be called here
dataTree.setSchemaContext(peopleSchemaContext);
}
private static ShardSnapshotState createSnapshot() {
- final TipProducingDataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- dataTree.setSchemaContext(SchemaContextHelper.select(SchemaContextHelper.CARS_YANG,
+ final DataTree dataTree = new InMemoryDataTreeFactory().create(
+ DataTreeConfiguration.DEFAULT_OPERATIONAL, SchemaContextHelper.select(SchemaContextHelper.CARS_YANG,
SchemaContextHelper.PEOPLE_YANG));
DataTreeSnapshot snapshot = dataTree.takeSnapshot();
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
+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.api.schema.tree.DataValidationFailedException;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
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.tree.InMemoryDataTreeFactory;
ShardTestKit.waitUntilLeader(shard);
- final DataTree store = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- store.setSchemaContext(SCHEMA_CONTEXT);
+ final DataTree store = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_OPERATIONAL,
+ SCHEMA_CONTEXT);
final ContainerNode container = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
ShardTestKit.waitUntilLeader(shard);
- final DataTree store = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- store.setSchemaContext(SCHEMA_CONTEXT);
+ final DataTree store = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_OPERATIONAL,
+ SCHEMA_CONTEXT);
final DataTreeModification writeMod = store.takeSnapshot().newModification();
final ContainerNode node = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
private void testCommitWhenTransactionHasModifications(final boolean readWrite) throws Exception {
new ShardTestKit(getSystem()) {
{
- final TipProducingDataTree dataTree = createDelegatingMockDataTree();
+ final DataTree dataTree = createDelegatingMockDataTree();
final TestActorRef<Shard> shard = actorFactory.createTestActor(
newShardBuilder().dataTree(dataTree).props().withDispatcher(Dispatchers.DefaultDispatcherId()),
"testCommitWhenTransactionHasModifications-" + readWrite);
public void testCommitPhaseFailure() throws Exception {
new ShardTestKit(getSystem()) {
{
- final TipProducingDataTree dataTree = createDelegatingMockDataTree();
+ final DataTree dataTree = createDelegatingMockDataTree();
final TestActorRef<Shard> shard = actorFactory.createTestActor(
newShardBuilder().dataTree(dataTree).props().withDispatcher(Dispatchers.DefaultDispatcherId()),
"testCommitPhaseFailure");
public void testPreCommitPhaseFailure() throws Exception {
new ShardTestKit(getSystem()) {
{
- final TipProducingDataTree dataTree = createDelegatingMockDataTree();
+ final DataTree dataTree = createDelegatingMockDataTree();
final TestActorRef<Shard> shard = actorFactory.createTestActor(
newShardBuilder().dataTree(dataTree).props().withDispatcher(Dispatchers.DefaultDispatcherId()),
"testPreCommitPhaseFailure");
public void testCanCommitPhaseFailure() throws Exception {
new ShardTestKit(getSystem()) {
{
- final TipProducingDataTree dataTree = createDelegatingMockDataTree();
+ final DataTree dataTree = createDelegatingMockDataTree();
final TestActorRef<Shard> shard = actorFactory.createTestActor(
newShardBuilder().dataTree(dataTree).props().withDispatcher(Dispatchers.DefaultDispatcherId()),
"testCanCommitPhaseFailure");
private void testImmediateCommitWithCanCommitPhaseFailure(final boolean readWrite) throws Exception {
new ShardTestKit(getSystem()) {
{
- final TipProducingDataTree dataTree = createDelegatingMockDataTree();
+ final DataTree dataTree = createDelegatingMockDataTree();
final TestActorRef<Shard> shard = actorFactory.createTestActor(
newShardBuilder().dataTree(dataTree).props().withDispatcher(Dispatchers.DefaultDispatcherId()),
"testImmediateCommitWithCanCommitPhaseFailure-" + readWrite);
*/
@Test
public void testInMemoryDataTreeRestore() throws ReadFailedException, DataValidationFailedException {
- final DataTree store = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- store.setSchemaContext(SCHEMA_CONTEXT);
+ final DataTree store = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_OPERATIONAL,
+ SCHEMA_CONTEXT);
final DataTreeModification putTransaction = store.takeSnapshot().newModification();
putTransaction.write(TestModel.TEST_PATH,
doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot();
doReturn(dataTreeModification).when(dataTreeSnapshot).newModification();
- doReturn(Optional.of(readResponse)).when(dataTreeModification).readNode(any(YangInstanceIdentifier.class));
+ doReturn(java.util.Optional.of(readResponse)).when(dataTreeModification).readNode(
+ any(YangInstanceIdentifier.class));
return dataTree;
}
import akka.testkit.TestActorRef;
import akka.util.Timeout;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.base.Stopwatch;
import com.google.common.util.concurrent.Uninterruptibles;
+import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
private static final AtomicInteger NEXT_SHARD_NUM = new AtomicInteger();
- protected void verifyEntityCandidate(NormalizedNode<?, ?> node, String entityType,
- YangInstanceIdentifier entityId, String candidateName, boolean expectPresent) {
+ 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);
assertTrue(node instanceof ContainerNode);
}
}
- protected void verifyEntityCandidate(String entityType, YangInstanceIdentifier entityId, String candidateName,
- Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader, boolean expectPresent) {
+ protected void verifyEntityCandidate(final String entityType, final YangInstanceIdentifier entityId,
+ final String candidateName, final Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader,
+ final boolean expectPresent) {
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
while (sw.elapsed(TimeUnit.MILLISECONDS) <= 5000) {
throw lastError;
}
- protected void verifyEntityCandidate(String entityType, YangInstanceIdentifier entityId, String candidateName,
- Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader) {
+ protected void verifyEntityCandidate(final String entityType, final YangInstanceIdentifier entityId,
+ final String candidateName, final Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader) {
verifyEntityCandidate(entityType, entityId, candidateName, reader, true);
}
- protected MapEntryNode getMapEntryNodeChild(DataContainerNode<? extends PathArgument> parent, QName childMap,
- QName child, Object key, boolean expectPresent) {
+ protected MapEntryNode getMapEntryNodeChild(final DataContainerNode<? extends PathArgument> parent,
+ final QName childMap, final QName child, final Object key, final boolean expectPresent) {
Optional<DataContainerChild<? extends PathArgument, ?>> childNode =
parent.getChild(new NodeIdentifier(childMap));
assertEquals("Missing " + childMap.toString(), true, childNode.isPresent());
return entityTypeEntry.isPresent() ? entityTypeEntry.get() : null;
}
- static void verifyOwner(String expected, String entityType, YangInstanceIdentifier entityId,
- Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader) {
+ static void verifyOwner(final String expected, final String entityType, final YangInstanceIdentifier entityId,
+ final Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader) {
AssertionError lastError = null;
YangInstanceIdentifier entityPath = entityPath(entityType, entityId).node(ENTITY_OWNER_QNAME);
Stopwatch sw = Stopwatch.createStarted();
}
@SuppressWarnings("checkstyle:IllegalCatch")
- static void verifyOwner(final TestActorRef<? extends EntityOwnershipShard> shard, String entityType,
- YangInstanceIdentifier entityId, String localMemberName) {
+ static void verifyOwner(final TestActorRef<? extends EntityOwnershipShard> shard, final String entityType,
+ final YangInstanceIdentifier entityId, final String localMemberName) {
verifyOwner(localMemberName, entityType, entityId, path -> {
try {
return AbstractShardTest.readStore(shard, path);
});
}
- protected void verifyNodeRemoved(YangInstanceIdentifier path,
- Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader) {
+ protected void verifyNodeRemoved(final YangInstanceIdentifier path,
+ final Function<YangInstanceIdentifier,NormalizedNode<?,?>> reader) {
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
while (sw.elapsed(TimeUnit.MILLISECONDS) <= 5000) {
throw lastError;
}
- static void writeNode(YangInstanceIdentifier path, NormalizedNode<?, ?> node, ShardDataTree shardDataTree)
- throws DataValidationFailedException {
+ static void writeNode(final YangInstanceIdentifier path, final NormalizedNode<?, ?> node,
+ final ShardDataTree shardDataTree) throws DataValidationFailedException {
DataTreeModification modification = shardDataTree.newModification();
modification.merge(path, node);
commit(shardDataTree, modification);
}
- static void deleteNode(YangInstanceIdentifier path, ShardDataTree shardDataTree)
+ static void deleteNode(final YangInstanceIdentifier path, final ShardDataTree shardDataTree)
throws DataValidationFailedException {
DataTreeModification modification = shardDataTree.newModification();
modification.delete(path);
commit(shardDataTree, modification);
}
- static void commit(ShardDataTree shardDataTree, DataTreeModification modification)
+ static void commit(final ShardDataTree shardDataTree, final DataTreeModification modification)
throws DataValidationFailedException {
modification.ready();
shardDataTree.getDataTree().validate(modification);
final boolean expIsOwner, final boolean expHasOwner, final boolean expInJeopardy) {
return Matchers.argThat(new ArgumentMatcher<DOMEntityOwnershipChange>() {
@Override
- public boolean matches(Object argument) {
+ public boolean matches(final Object argument) {
DOMEntityOwnershipChange change = (DOMEntityOwnershipChange) argument;
return expEntity.equals(change.getEntity()) && expWasOwner == change.getState().wasOwner()
&& expIsOwner == change.getState().isOwner() && expHasOwner == change.getState().hasOwner()
}
@Override
- public void describeTo(Description description) {
+ public void describeTo(final Description description) {
description.appendValue(new DOMEntityOwnershipChange(expEntity, EntityOwnershipChangeState.from(
expWasOwner, expIsOwner, expHasOwner), expInJeopardy));
}
static DOMEntityOwnershipChange ownershipChange(final DOMEntity expEntity) {
return Matchers.argThat(new ArgumentMatcher<DOMEntityOwnershipChange>() {
@Override
- public boolean matches(Object argument) {
+ public boolean matches(final Object argument) {
DOMEntityOwnershipChange change = (DOMEntityOwnershipChange) argument;
return expEntity.equals(change.getEntity());
}
@Override
- public void describeTo(Description description) {
+ public void describeTo(final Description description) {
description.appendValue(new DOMEntityOwnershipChange(expEntity, EntityOwnershipChangeState.from(
false, false, false)));
}
}
@SuppressWarnings("checkstyle:IllegalCatch")
- static void verifyNoOwnerSet(TestActorRef<? extends EntityOwnershipShard> shard, String entityType,
- YangInstanceIdentifier entityId) {
+ static void verifyNoOwnerSet(final TestActorRef<? extends EntityOwnershipShard> shard, final String entityType,
+ final YangInstanceIdentifier entityId) {
YangInstanceIdentifier entityPath = entityPath(entityType, entityId).node(ENTITY_OWNER_QNAME);
try {
NormalizedNode<?, ?> node = AbstractShardTest.readStore(shard, entityPath);
}
static void verifyRaftState(final TestActorRef<? extends EntityOwnershipShard> shard,
- Consumer<OnDemandRaftState> verifier)
+ final Consumer<OnDemandRaftState> verifier)
throws Exception {
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
throw lastError;
}
- static ShardIdentifier newShardId(String memberName) {
+ static ShardIdentifier newShardId(final String memberName) {
return ShardIdentifier.create("entity-ownership", MemberName.forName(memberName),
"operational" + NEXT_SHARD_NUM.getAndIncrement());
}
@SuppressWarnings("checkstyle:IllegalCatch")
- void verifyEntityCandidateRemoved(final TestActorRef<EntityOwnershipShard> shard, String entityType,
- YangInstanceIdentifier entityId, String candidateName) {
+ void verifyEntityCandidateRemoved(final TestActorRef<EntityOwnershipShard> shard, final String entityType,
+ final YangInstanceIdentifier entityId, final String candidateName) {
verifyNodeRemoved(candidatePath(entityType, entityId, candidateName), path -> {
try {
return AbstractShardTest.readStore(shard, path);
}
@SuppressWarnings("checkstyle:IllegalCatch")
- void verifyCommittedEntityCandidate(final TestActorRef<? extends EntityOwnershipShard> shard, String entityType,
- YangInstanceIdentifier entityId, String candidateName) {
+ void verifyCommittedEntityCandidate(final TestActorRef<? extends EntityOwnershipShard> shard,
+ final String entityType, final YangInstanceIdentifier entityId, final String candidateName) {
verifyEntityCandidate(entityType, entityId, candidateName, path -> {
try {
return AbstractShardTest.readStore(shard, path);
}
@SuppressWarnings("checkstyle:IllegalCatch")
- void verifyNoEntityCandidate(final TestActorRef<? extends EntityOwnershipShard> shard, String entityType,
- YangInstanceIdentifier entityId, String candidateName) {
+ void verifyNoEntityCandidate(final TestActorRef<? extends EntityOwnershipShard> shard, final String entityType,
+ final YangInstanceIdentifier entityId, final String candidateName) {
verifyEntityCandidate(entityType, entityId, candidateName, path -> {
try {
return AbstractShardTest.readStore(shard, path);
assertStatistics(statistics, REMOTE_MEMBER_NAME2, 0L);
// Clear the owner for entity 2
- writeNode(entityPath(ENTITY_TYPE, ENTITY_ID2), entityEntryWithOwner(ENTITY_ID2, null));
+ writeNode(entityPath(ENTITY_TYPE, ENTITY_ID2), entityEntryWithOwner(ENTITY_ID2, ""));
statistics = ownershipStatistics.all();
assertStatistics(statistics, LOCAL_MEMBER_NAME, 1L);
assertStatistics(statistics, REMOTE_MEMBER_NAME1, 0L);
// Clear the owner for entity 2 again - expect no change
- writeNode(entityPath(ENTITY_TYPE, ENTITY_ID2), entityEntryWithOwner(ENTITY_ID2, null));
+ writeNode(entityPath(ENTITY_TYPE, ENTITY_ID2), entityEntryWithOwner(ENTITY_ID2, ""));
statistics = ownershipStatistics.all();
assertStatistics(statistics, LOCAL_MEMBER_NAME, 1L);
assertStatistics(statistics, REMOTE_MEMBER_NAME1, 0L);
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import java.io.NotSerializableException;
import java.util.List;
import org.junit.Test;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.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.api.schema.tree.TipProducingDataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
public class ReadyLocalTransactionSerializerTest extends AbstractTest {
@Test
- public void testToAndFromBinary() {
- TipProducingDataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
- dataTree.setSchemaContext(TestModel.createTestContext());
+ public void testToAndFromBinary() throws NotSerializableException {
+ DataTree dataTree = new InMemoryDataTreeFactory().create(
+ DataTreeConfiguration.DEFAULT_OPERATIONAL, TestModel.createTestContext());
DataTreeModification modification = dataTree.takeSnapshot().newModification();
ContainerNode writeData = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates;
+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.api.schema.tree.TipProducingDataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
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.impl.ImmutableContainerNodeBuilder;
@Test
public void testUnmodifiedRootCandidate() throws Exception {
- final TipProducingDataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
- dataTree.setSchemaContext(SchemaContextHelper.select(SchemaContextHelper.CARS_YANG));
+ final DataTree dataTree = new InMemoryDataTreeFactory().create(
+ DataTreeConfiguration.DEFAULT_CONFIGURATION, SchemaContextHelper.select(SchemaContextHelper.CARS_YANG));
DataTreeModification modification = dataTree.takeSnapshot().newModification();
modification.ready();
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.fail;
-import com.google.common.base.Optional;
-import com.google.common.collect.Lists;
import com.google.common.util.concurrent.Uninterruptibles;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class MockDataTreeChangeListener implements DOMDataTreeChangeListener {
- private final List<DataTreeCandidate> changeList = Lists.newArrayList();
+ private final List<DataTreeCandidate> changeList = new ArrayList<>();
private volatile CountDownLatch changeLatch;
private int expChangeEventCount;
- public MockDataTreeChangeListener(int expChangeEventCount) {
+ public MockDataTreeChangeListener(final int expChangeEventCount) {
reset(expChangeEventCount);
}
- public void reset(int newExpChangeEventCount) {
+ public void reset(final int newExpChangeEventCount) {
changeLatch = new CountDownLatch(newExpChangeEventCount);
this.expChangeEventCount = newExpChangeEventCount;
synchronized (changeList) {
}
@SuppressWarnings({ "unchecked", "rawtypes" })
- public void waitForChangeEvents(YangInstanceIdentifier... expPaths) {
+ public void waitForChangeEvents(final YangInstanceIdentifier... expPaths) {
boolean done = Uninterruptibles.awaitUninterruptibly(changeLatch, 5, TimeUnit.SECONDS);
if (!done) {
fail(String.format("Missing change notifications. Expected: %d. Actual: %d",
}
}
- public void verifyNotifiedData(YangInstanceIdentifier... paths) {
+ public void verifyNotifiedData(final YangInstanceIdentifier... paths) {
Set<YangInstanceIdentifier> pathSet = new HashSet<>(Arrays.asList(paths));
synchronized (changeList) {
for (DataTreeCandidate c : changeList) {
}
}
- public void expectNoMoreChanges(String assertMsg) {
+ public void expectNoMoreChanges(final String assertMsg) {
Uninterruptibles.sleepUninterruptibly(500, TimeUnit.MILLISECONDS);
synchronized (changeList) {
assertEquals(assertMsg, expChangeEventCount, changeList.size());
}
}
- public void verifyNoNotifiedData(YangInstanceIdentifier... paths) {
+ public void verifyNoNotifiedData(final YangInstanceIdentifier... paths) {
Set<YangInstanceIdentifier> pathSet = new HashSet<>(Arrays.asList(paths));
synchronized (changeList) {
for (DataTreeCandidate c : changeList) {
import static org.opendaylight.controller.md.cluster.datastore.model.TestModel.outerNode;
import static org.opendaylight.controller.md.cluster.datastore.model.TestModel.outerNodeEntry;
-import com.google.common.base.Optional;
import com.google.common.reflect.Reflection;
import java.lang.reflect.InvocationTargetException;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
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.tree.DataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateTip;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
+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.api.schema.tree.DataTreeModificationCursor;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
@Mock
private DataTreeModification mockModification;
- private TipProducingDataTree dataTree;
+ private DataTree dataTree;
private DataTreeModification realModification;
private DataTreeModification proxyModification;
private PruningDataTreeModification pruningDataTreeModification;
public void setUp() {
MockitoAnnotations.initMocks(this);
- dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
- dataTree.setSchemaContext(SCHEMA_CONTEXT);
+ dataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_CONFIGURATION,
+ SCHEMA_CONTEXT);
realModification = dataTree.takeSnapshot().newModification();
proxyModification = Reflection.newProxy(DataTreeModification.class, (proxy, method, args) -> {
verify(mockModification, times(1)).merge(path, normalizedNode);
- DataTreeCandidateTip candidate = getCandidate();
+ DataTreeCandidate candidate = getCandidate();
assertEquals("getModificationType", ModificationType.UNMODIFIED, candidate.getRootNode().getModificationType());
}
new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outerNode).build();
Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(path);
- assertEquals("After pruning present", true, actual.isPresent());
+ assertTrue("After pruning present", actual.isPresent());
assertEquals("After pruning", prunedNode, actual.get());
}
verify(mockModification, times(1)).merge(path, normalizedNode);
- DataTreeCandidateTip candidate = getCandidate();
+ DataTreeCandidate candidate = getCandidate();
assertEquals("getModificationType", ModificationType.UNMODIFIED, candidate.getRootNode().getModificationType());
}
@Test
public void testWriteRootNode() throws Exception {
- final DataTree localDataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
- localDataTree.setSchemaContext(SCHEMA_CONTEXT);
+ final DataTree localDataTree = new InMemoryDataTreeFactory().create(
+ DataTreeConfiguration.DEFAULT_CONFIGURATION, SCHEMA_CONTEXT);
DataTreeModification mod = localDataTree.takeSnapshot().newModification();
mod.write(CarsModel.BASE_PATH, CarsModel.create());
dataTree.commit(getCandidate());
Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.EMPTY);
- assertEquals("Root present", true, actual.isPresent());
+ assertTrue("Root present", actual.isPresent());
assertEquals("Root node", normalizedNode, actual.get());
}
verify(mockModification, times(1)).write(path, normalizedNode);
- DataTreeCandidateTip candidate = getCandidate();
+ DataTreeCandidate candidate = getCandidate();
assertEquals("getModificationType", ModificationType.UNMODIFIED, candidate.getRootNode().getModificationType());
}
.withChild(ImmutableNodes.leafNode(NAME_QNAME, "name")).build();
Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(path);
- assertEquals("After pruning present", true, actual.isPresent());
+ assertTrue("After pruning present", actual.isPresent());
assertEquals("After pruning", prunedNode, actual.get());
}
dataTreeModification instanceof PruningDataTreeModification);
}
- private DataTreeCandidateTip getCandidate() throws DataValidationFailedException {
+ private DataTreeCandidate getCandidate() throws DataValidationFailedException {
pruningDataTreeModification.ready();
DataTreeModification mod = pruningDataTreeModification.delegate();
mod = mod == proxyModification ? realModification : mod;
dataTree.validate(mod);
- DataTreeCandidateTip candidate = dataTree.prepare(mod);
- return candidate;
+ return dataTree.prepare(mod);
}
}
captorForSubtrees.capture());
final List<Collection<DataTreeCandidate>> capturedValue = captorForChanges.getAllValues();
- final Optional<NormalizedNode<?, ?>> dataAfter =
+ final java.util.Optional<NormalizedNode<?, ?>> dataAfter =
capturedValue.get(0).iterator().next().getRootNode().getDataAfter();
final NormalizedNode<?,?> expected = ImmutableContainerNodeBuilder.create()
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
-import java.io.InputStream;
-import java.util.ArrayList;
import java.util.HashSet;
-import java.util.List;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public final class CompositeModel {
}
- public static InputStream getDatastoreTestInputStream() {
- return getInputStream(DATASTORE_TEST_YANG);
- }
-
- public static InputStream getDatastoreAugInputStream() {
- return getInputStream(DATASTORE_AUG_YANG);
- }
-
- public static InputStream getDatastoreTestNotificationInputStream() {
- return getInputStream(DATASTORE_TEST_NOTIFICATION_YANG);
- }
-
- private static InputStream getInputStream(final String resourceName) {
- return CompositeModel.class.getResourceAsStream(resourceName);
- }
-
public static SchemaContext createTestContext() {
- List<InputStream> inputStreams = new ArrayList<>();
- inputStreams.add(getDatastoreTestInputStream());
- inputStreams.add(getDatastoreAugInputStream());
- inputStreams.add(getDatastoreTestNotificationInputStream());
-
- try {
- return YangParserTestUtils.parseYangStreams(inputStreams);
- } catch (ReactorException e) {
- throw new RuntimeException("Unable to build schema context from " + inputStreams, e);
- }
+ return YangParserTestUtils.parseYangResources(CompositeModel.class, DATASTORE_TEST_YANG, DATASTORE_AUG_YANG,
+ DATASTORE_TEST_NOTIFICATION_YANG);
}
/**
package org.opendaylight.controller.md.cluster.datastore.model;
import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.List;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public final class SchemaContextHelper {
}
public static SchemaContext select(final String... schemaFiles) {
- List<InputStream> streams = new ArrayList<>(schemaFiles.length);
-
- for (String schemaFile : schemaFiles) {
- streams.add(getInputStream(schemaFile));
- }
-
- try {
- return YangParserTestUtils.parseYangStreams(streams);
- } catch (ReactorException e) {
- throw new RuntimeException("Unable to build schema context from " + streams, e);
- }
+ return YangParserTestUtils.parseYangResources(SchemaContextHelper.class, schemaFiles);
}
public static SchemaContext distributedShardedDOMDataTreeSchemaContext() {
- final List<InputStream> streams = new ArrayList<>();
- try {
- // we need prefix-shard-configuration and odl-datastore-test models
- // for DistributedShardedDOMDataTree tests
- streams.add(getInputStream(ODL_DATASTORE_TEST_YANG));
- streams.add(new FileInputStream("src/main/yang/prefix-shard-configuration.yang"));
- return YangParserTestUtils.parseYangStreams(streams);
- } catch (FileNotFoundException | ReactorException e) {
- throw new RuntimeException(e);
- }
+ // we need prefix-shard-configuration and odl-datastore-test models
+ // for DistributedShardedDOMDataTree tests
+ return YangParserTestUtils.parseYangResources(SchemaContextHelper.class, ODL_DATASTORE_TEST_YANG,
+ "/META-INF/yang/prefix-shard-configuration@2017-01-10.yang");
}
public static SchemaContext entityOwners() {
- try {
- return YangParserTestUtils.parseYangSources(new File("src/main/yang/entity-owners.yang"));
- } catch (IOException | ReactorException e) {
- throw new RuntimeException(e);
- }
+ return YangParserTestUtils.parseYangFiles(new File("src/main/yang/entity-owners.yang"));
}
}
*/
package org.opendaylight.controller.md.cluster.datastore.model;
-import com.google.common.io.Resources;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Collections;
-import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
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.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public final class TestModel {
}
public static SchemaContext createTestContext() {
- final List<InputStream> sources;
-
- try {
- sources = Collections.singletonList(
- Resources.asByteSource(TestModel.class.getResource(DATASTORE_TEST_YANG)).openStream());
- } catch (IOException e1) {
- throw new ExceptionInInitializerError(e1);
- }
-
- try {
- return YangParserTestUtils.parseYangStreams(sources);
- } catch (ReactorException e) {
- throw new RuntimeException("Unable to build schema context from " + sources, e);
- }
+ return YangParserTestUtils.parseYangResource(DATASTORE_TEST_YANG);
}
public static DataContainerChild<?, ?> outerNode(final int... ids) {
package org.opendaylight.controller.md.sal.dom.api;
import static org.junit.Assert.assertNotNull;
+
import com.google.common.util.concurrent.CheckedFuture;
import java.net.URI;
import java.util.Collections;
* can be used.
*/
public abstract class AbstractDOMDataTreeServiceTestSuite {
- protected static final QNameModule TEST_MODULE = QNameModule.create(URI.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:test:store"), null);
+ protected static final QNameModule TEST_MODULE = QNameModule.create(URI.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:test:store"));
protected static final YangInstanceIdentifier UNORDERED_CONTAINER_IID = YangInstanceIdentifier.create(
new NodeIdentifier(QName.create(TEST_MODULE, "lists")),
*/
ExecutorService listenableFutureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(
getMaxDataBrokerFutureCallbackPoolSize(), getMaxDataBrokerFutureCallbackQueueSize(),
- "CommitFutures");
+ "CommitFutures", SerializedDOMDataBroker.class);
final List<AbstractMXBean> mBeans = Lists.newArrayList();
final DurationStatisticsTracker commitStatsTracker;
* system it's running on.
*/
ExecutorService commitExecutor = SpecialExecutors.newBoundedSingleThreadExecutor(
- getMaxDataBrokerCommitQueueSize(), "WriteTxCommit");
+ getMaxDataBrokerCommitQueueSize(), "WriteTxCommit", SerializedDOMDataBroker.class);
SerializedDOMDataBroker sdb = new SerializedDOMDataBroker(datastores,
new DeadlockDetectingListeningExecutorService(commitExecutor,
*/
package org.opendaylight.controller.config.yang.md.sal.dom.impl;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.controller.config.api.osgi.WaitingServiceTracker;
import org.opendaylight.controller.sal.core.api.model.SchemaService;
import org.opendaylight.controller.sal.core.api.model.YangTextSourceProvider;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.osgi.framework.BundleContext;
}
@Override
- public CheckedFuture<? extends YangTextSchemaSource, SchemaSourceException> getSource(
- SourceIdentifier sourceIdentifier) {
+ public ListenableFuture<? extends YangTextSchemaSource> getSource(
+ final SourceIdentifier sourceIdentifier) {
return sourceProvider.getSource(sourceIdentifier);
}
}
private static RpcDefinition findRpcDefinition(final SchemaContext context, final SchemaPath schemaPath) {
if (context != null) {
final QName qname = schemaPath.getPathFromRoot().iterator().next();
- final Module module = context.findModuleByNamespaceAndRevision(qname.getNamespace(), qname.getRevision());
+ final Module module = context.findModule(qname.getModule()).orElse(null);
if (module != null && module.getRpcs() != null) {
for (RpcDefinition rpc : module.getRpcs()) {
if (qname.equals(rpc.getQName())) {
*/
package org.opendaylight.controller.md.sal.dom.broker.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementation;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.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.api.schema.tree.DataTreeSnapshot;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
this.txIdentifier = checkNotNull(readWriteTxId);
this.initialReadMap = Maps.newEnumMap(LogicalDatastoreType.class);
- final InMemoryDataTreeFactory treeFactory = InMemoryDataTreeFactory.getInstance();
+ final InMemoryDataTreeFactory treeFactory = new InMemoryDataTreeFactory();
final ImmutableMap.Builder<LogicalDatastoreType, DataTreeSnapshot> snapshotMapBuilder = ImmutableMap.builder();
final ImmutableMap.Builder<LogicalDatastoreType, Queue<Modification>> modificationHistoryMapBuilder
= ImmutableMap.builder();
for (final LogicalDatastoreType store : LogicalDatastoreType.values()) {
- final DataTree tree = treeFactory.create(treeTypeForStore(store));
+ final DataTree tree = treeFactory.create(treeConfigForStore(store));
tree.setSchemaContext(ctx);
snapshotMapBuilder.put(store, tree.takeSnapshot());
mod.write(path, result.get());
}
applyModificationHistoryToSnapshot(mod, currentHistory);
- readResult.set(mod.readNode(path));
+ readResult.set(Optional.fromJavaUtil(mod.readNode(path)));
}
@Override
private void initialRead(final YangInstanceIdentifier path) {
root = path;
- final InMemoryDataTreeFactory treeFactory = InMemoryDataTreeFactory.getInstance();
for (final LogicalDatastoreType store : LogicalDatastoreType.values()) {
initialReadMap.put(store, readTxDelegate.read(store, path));
}
}
- private TreeType treeTypeForStore(final LogicalDatastoreType store) {
- return store == LogicalDatastoreType.CONFIGURATION ? TreeType.CONFIGURATION : TreeType.OPERATIONAL;
+ private static DataTreeConfiguration treeConfigForStore(final LogicalDatastoreType store) {
+ return store == LogicalDatastoreType.CONFIGURATION ? DataTreeConfiguration.DEFAULT_CONFIGURATION
+ : DataTreeConfiguration.DEFAULT_OPERATIONAL;
}
- private void applyModificationHistoryToSnapshot(final DataTreeModification dataTreeModification,
+ private static void applyModificationHistoryToSnapshot(final DataTreeModification dataTreeModification,
final Queue<Modification> modificationHistory) {
while (!modificationHistory.isEmpty()) {
final Modification modification = modificationHistory.poll();
}
@Override
- public void close() throws Exception {
+ public void close() {
unregisterMountPoint(mountPoint.getIdentifier());
}
}
package org.opendaylight.controller.sal.dom.broker.util;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import java.net.URI;
import java.util.Collection;
-import java.util.Date;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
return getCurrentSchema().getExtensions();
}
- @Override
- public Module findModuleByName(final String string, final Date date) {
- return getCurrentSchema().findModuleByName(string, date);
- }
-
- @Override
- public Set<Module> findModuleByNamespace(final URI uri) {
- return getCurrentSchema().findModuleByNamespace(uri);
- }
-
- @Override
- public Module findModuleByNamespaceAndRevision(final URI uri, final Date date) {
- return getCurrentSchema().findModuleByNamespaceAndRevision(uri, date);
- }
-
- @Override
- public Optional<String> getModuleSource(final ModuleIdentifier moduleIdentifier) {
- return getCurrentSchema().getModuleSource(moduleIdentifier);
- }
-
- @Override
- public Set<ModuleIdentifier> getAllModuleIdentifiers() {
- return getCurrentSchema().getAllModuleIdentifiers();
- }
-
@Override
public boolean isPresenceContainer() {
return getCurrentSchema().isPresenceContainer();
}
@Override
- public DataSchemaNode getDataChildByName(final QName name) {
- return getCurrentSchema().getDataChildByName(name);
+ public Optional<DataSchemaNode> findDataChildByName(final QName name) {
+ return getCurrentSchema().findDataChildByName(name);
}
@Override
}
@Override
- public Set<AugmentationSchema> getAvailableAugmentations() {
+ public Set<AugmentationSchemaNode> getAvailableAugmentations() {
return getCurrentSchema().getAvailableAugmentations();
}
return getCurrentSchema().isConfiguration();
}
- @Override
- public ConstraintDefinition getConstraints() {
- return getCurrentSchema().getConstraints();
- }
-
@Override
public QName getQName() {
return getCurrentSchema().getQName();
}
@Override
- public String getDescription() {
+ public Optional<String> getDescription() {
return getCurrentSchema().getDescription();
}
@Override
- public String getReference() {
+ public Optional<String> getReference() {
return getCurrentSchema().getReference();
}
public Status getStatus() {
return getCurrentSchema().getStatus();
}
+
+ @Override
+ public Optional<Module> findModule(final String name, final Optional<Revision> revision) {
+ return getCurrentSchema().findModule(name, revision);
+ }
+
+ @Override
+ public Optional<Module> findModule(final QNameModule qnameModule) {
+ return getCurrentSchema().findModule(qnameModule);
+ }
}
import static com.google.common.base.Preconditions.checkState;
import com.google.common.collect.Lists;
+import java.util.Collection;
import java.util.Iterator;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.MustDefinition;
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
+import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
}
QName firstNode = path.iterator().next();
- DataNodeContainer previous = schema.findModuleByNamespaceAndRevision(firstNode.getNamespace(),
- firstNode.getRevision());
+ DataNodeContainer previous = schema.findModule(firstNode.getModule()).orElse(null);
Iterator<QName> iterator = path.iterator();
while (iterator.hasNext()) {
}
private static DataSchemaNode searchInCases(final ChoiceSchemaNode choiceNode, final QName arg) {
- Set<ChoiceCaseNode> cases = choiceNode.getCases();
- for (ChoiceCaseNode caseNode : cases) {
+ for (CaseSchemaNode caseNode : choiceNode.getCases().values()) {
DataSchemaNode node = caseNode.getDataChildByName(arg);
if (node != null) {
return node;
}
@Override
- public DataSchemaNode getDataChildByName(final QName name) {
+ public Optional<DataSchemaNode> findDataChildByName(final QName name) {
// TODO Auto-generated method stub
return null;
}
}
@Override
- public Set<AugmentationSchema> getAvailableAugmentations() {
+ public Set<AugmentationSchemaNode> getAvailableAugmentations() {
// TODO Auto-generated method stub
return null;
}
}
@Override
- public ConstraintDefinition getConstraints() {
+ public QName getQName() {
// TODO Auto-generated method stub
return null;
}
@Override
- public QName getQName() {
+ public SchemaPath getPath() {
// TODO Auto-generated method stub
return null;
}
@Override
- public SchemaPath getPath() {
+ public Optional<String> getDescription() {
+ return Optional.empty();
+ }
+
+ @Override
+ public Optional<String> getReference() {
+ return Optional.empty();
+ }
+
+ @Override
+ public Status getStatus() {
// TODO Auto-generated method stub
return null;
}
@Override
- public String getDescription() {
+ public List<UnknownSchemaNode> getUnknownSchemaNodes() {
// TODO Auto-generated method stub
return null;
}
@Override
- public String getReference() {
+ public boolean isPresenceContainer() {
// TODO Auto-generated method stub
- return null;
+ return false;
}
@Override
- public Status getStatus() {
+ public Set<NotificationDefinition> getNotifications() {
// TODO Auto-generated method stub
return null;
}
@Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
+ public Set<ActionDefinition> getActions() {
// TODO Auto-generated method stub
return null;
}
@Override
- public boolean isPresenceContainer() {
+ public Optional<RevisionAwareXPath> getWhenCondition() {
// TODO Auto-generated method stub
- return false;
+ return null;
}
+ @Override
+ public Collection<MustDefinition> getMustConstraints() {
+ // TODO Auto-generated method stub
+ return null;
+ }
}
}
.build();
commitExecutor = new CommitExecutorService(Executors.newSingleThreadExecutor());
- futureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(1, 5, "FCB");
+ futureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(1, 5, "FCB", DOMBrokerTest.class);
executor = new DeadlockDetectingListeningExecutorService(commitExecutor,
TransactionCommitDeadlockException
.DEADLOCK_EXCEPTION_SUPPLIER,
.build();
commitExecutor = new CommitExecutorService(Executors.newSingleThreadExecutor());
- futureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(1, 5, "FCB");
+ futureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(1, 5, "FCB",
+ DOMDataTreeListenerTest.class);
executor = new DeadlockDetectingListeningExecutorService(commitExecutor,
TransactionCommitDeadlockException
.DEADLOCK_EXCEPTION_SUPPLIER,
*/
package org.opendaylight.controller.md.sal.dom.store.impl;
-import java.io.InputStream;
-import java.util.Collections;
-import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public final class TestModel {
YangInstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
private static final String DATASTORE_TEST_YANG = "/odl-datastore-test.yang";
- private static InputStream getInputStream() {
- return TestModel.class.getResourceAsStream(DATASTORE_TEST_YANG);
- }
-
public static SchemaContext createTestContext() {
- final List<InputStream> streams = Collections.singletonList(getInputStream());
-
- try {
- return YangParserTestUtils.parseYangStreams(streams);
- } catch (ReactorException e) {
- throw new RuntimeException("Unable to build schema context from " + streams, e);
- }
+ return YangParserTestUtils.parseYangResource(DATASTORE_TEST_YANG);
}
}
package org.opendaylight.controller.sal.core.spi.data;
import static com.google.common.base.Preconditions.checkNotNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
}
try {
- return Futures.immediateCheckedFuture(snapshot.readNode(path));
+ return Futures.immediateCheckedFuture(Optional.fromJavaUtil(snapshot.readNode(path)));
} catch (Exception e) {
LOG.error("Tx: {} Failed Read of {}", getIdentifier(), path, e);
return Futures.immediateFailedCheckedFuture(new ReadFailedException("Read failed",e));
package org.opendaylight.controller.sal.core.spi.data;
import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.base.Optional;
* @return null if the the transaction has been closed;
*/
final Optional<NormalizedNode<?, ?>> readSnapshotNode(final YangInstanceIdentifier path) {
- return readyImpl == null ? null : mutableTree.readNode(path);
+ return readyImpl == null ? null : Optional.fromJavaUtil(mutableTree.readNode(path));
}
private final void checkNotReady() {
- checkState(readyImpl != null, "Transaction %s is no longer open. No further modifications allowed.", getIdentifier());
+ checkState(readyImpl != null, "Transaction %s is no longer open. No further modifications allowed.",
+ getIdentifier());
}
@Override
*/
package org.opendaylight.controller.md.sal.dom.store.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import java.util.Optional;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
+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.api.schema.tree.DataTreeSnapshot;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
switch (type) {
case CONFIGURATION:
- dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
+ dataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_CONFIGURATION);
break;
case OPERATIONAL:
- dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
+ dataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_OPERATIONAL);
break;
default:
throw new IllegalArgumentException("Data store " + type + " not supported");
int dclExecutorMaxPoolSize = actualProperties.getMaxDataChangeExecutorPoolSize();
ExecutorService dataChangeListenerExecutor = SpecialExecutors.newBlockingBoundedFastThreadPool(
- dclExecutorMaxPoolSize, dclExecutorMaxQueueSize, name + "-DCL" );
+ dclExecutorMaxPoolSize, dclExecutorMaxQueueSize, name + "-DCL", InMemoryDOMDataStore.class);
final InMemoryDOMDataStore dataStore = new InMemoryDOMDataStore(name, type, dataChangeListenerExecutor,
actualProperties.getMaxDataChangeListenerQueueSize(), debugTransactions);
*/
package org.opendaylight.controller.md.sal.dom.store.impl;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
+import java.util.Optional;
import java.util.concurrent.ExecutorService;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener;
package org.opendaylight.controller.md.sal.dom.store.impl;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import java.util.Collection;
import java.util.Map.Entry;
+import java.util.Optional;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.Builder;
import org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.SimpleEventFactory;
*/
package org.opendaylight.controller.md.sal.dom.store.impl.tree;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
+import java.util.Optional;
import org.opendaylight.controller.md.sal.dom.spi.RegistrationTreeNode;
import org.opendaylight.controller.md.sal.dom.store.impl.DataChangeListenerRegistration;
import org.opendaylight.yangtools.concepts.Identifiable;
public Optional<ListenerNode> getChild(final PathArgument child) {
final RegistrationTreeNode<DataChangeListenerRegistration<?>> c = delegate.getExactChild(child);
if (c == null) {
- return Optional.absent();
+ return Optional.empty();
}
return Optional.of(new ListenerNode(c));
this.schemaContext = context.tryToCreateSchemaContext().get();
this.dclExecutorService = new TestDCLExecutorService(
- SpecialExecutors.newBlockingBoundedFastThreadPool(1, 10, "DCL" ));
+ SpecialExecutors.newBlockingBoundedFastThreadPool(1, 10, "DCL",
+ AbstractDataChangeListenerTest.class));
this.datastore = new InMemoryDOMDataStore("TEST", this.dclExecutorService);
this.datastore.onGlobalContextUpdated(this.schemaContext);
*/
package org.opendaylight.controller.md.sal.dom.store.impl;
-import java.io.InputStream;
-import java.util.Collections;
-import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class TestModel {
YangInstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
private static final String DATASTORE_TEST_YANG = "/odl-datastore-test.yang";
- private static InputStream getInputStream() {
- return TestModel.class.getResourceAsStream(DATASTORE_TEST_YANG);
- }
-
public static SchemaContext createTestContext() {
- final List<InputStream> streams = Collections.singletonList(getInputStream());
-
- try {
- return YangParserTestUtils.parseYangStreams(streams);
- } catch (ReactorException e) {
- throw new RuntimeException("Unable to build schema context from " + streams, e);
- }
+ return YangParserTestUtils.parseYangResource(DATASTORE_TEST_YANG);
}
}
static final QName TEST_RPC_INPUT = QName.create(TEST_NS, TEST_REV, "input");
static final QName TEST_RPC_INPUT_DATA = QName.create(TEST_NS, TEST_REV, "input-data");
static final QName TEST_RPC_OUTPUT = QName.create(TEST_NS, TEST_REV, "output");
- static final QName TEST_RPC_OUTPUT_DATA = new QName(TEST_URI, "output-data");
+ static final QName TEST_RPC_OUTPUT_DATA = QName.create(TEST_URI, "output-data");
static final SchemaPath TEST_RPC_TYPE = SchemaPath.create(true, TEST_RPC);
import com.google.common.util.concurrent.Uninterruptibles;
import com.typesafe.config.ConfigFactory;
import java.net.URI;
-import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
}
@Test
- public void testAddRoutesConcurrency() throws Exception {
+ public void testAddRoutesConcurrency() {
final JavaTestKit testKit = new JavaTestKit(node1);
final int nRoutes = 500;
final Collection<DOMRpcIdentifier> added = new ArrayList<>(nRoutes);
for (int i = 0; i < nRoutes; i++) {
final DOMRpcIdentifier routeId = DOMRpcIdentifier.create(SchemaPath.create(true,
- new QName(new URI("/mockrpc"), "type" + i)));
+ QName.create(URI.create("/mockrpc"), "type" + i)));
added.add(routeId);
//Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
}
}
- private List<DOMRpcIdentifier> createRouteIds() throws URISyntaxException {
- QName type = new QName(new URI("/mockrpc"), "mockrpc" + routeIdCounter++);
+ private List<DOMRpcIdentifier> createRouteIds() {
+ QName type = QName.create(URI.create("/mockrpc"), "mockrpc" + routeIdCounter++);
List<DOMRpcIdentifier> routeIds = new ArrayList<>(1);
routeIds.add(DOMRpcIdentifier.create(SchemaPath.create(true, type)));
return routeIds;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.HashSet;
import java.util.Set;
import javax.annotation.concurrent.GuardedBy;
"Source provider is not available", sourceIdentifier));
}
- return (CheckedFuture<YangTextSchemaSource, SchemaSourceException>) yangProvider.getSource(sourceIdentifier);
+ return Futures.makeChecked((ListenableFuture<YangTextSchemaSource>) yangProvider.getSource(sourceIdentifier),
+ e -> new SchemaSourceException("Error retrieving source", e));
}
}
*/
package org.opendaylight.controller.clustering.it.provider;
-import com.google.common.base.Optional;
import com.google.common.base.Verify;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
+import java.util.Optional;
import org.opendaylight.mdsal.common.api.DataValidationFailedException;
import org.opendaylight.mdsal.common.api.PostCanCommitStep;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCandidate;
Code Review / controller.git / commitdiff