*/
package org.opendaylight.controller.config.api;
-import javax.management.ObjectName;
-
import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface;
import org.opendaylight.yangtools.concepts.Identifiable;
+import org.opendaylight.yangtools.yang.binding.BaseIdentity;
+
+import javax.management.ObjectName;
/**
* Each new {@link org.opendaylight.controller.config.spi.Module} can receive
<T> T resolveInstance(Class<T> expectedType, ObjectName objectName,
JmxAttribute jmxAttribute);
+ // TODO finish javadoc
+
+ /**
+ * To be used during commit phase to resolve identity-ref config attributes.
+ *
+ * @return actual class object generated from identity
+ */
+ <T extends BaseIdentity> Class<? extends T> resolveIdentity(IdentityAttributeRef identityRef, Class<T> expectedBaseClass);
+
+ <T extends BaseIdentity> void validateIdentity(IdentityAttributeRef identityRef, Class<T> expectedBaseClass, JmxAttribute jmxAttribute);
+
}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * 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
+ */
+package org.opendaylight.controller.config.api;
+
+import org.opendaylight.yangtools.yang.binding.BaseIdentity;
+
+import java.beans.ConstructorProperties;
+
+public final class IdentityAttributeRef {
+
+ public static final String QNAME_ATTR_NAME = "qNameOfIdentity";
+
+ private final String qNameOfIdentity;
+
+ @ConstructorProperties(QNAME_ATTR_NAME)
+ public IdentityAttributeRef(String qNameOfIdentity) {
+ if (qNameOfIdentity == null)
+ throw new NullPointerException("Parameter " + QNAME_ATTR_NAME + " is null");
+ this.qNameOfIdentity = qNameOfIdentity;
+ }
+
+ public String getqNameOfIdentity() {
+ return qNameOfIdentity;
+ }
+
+ public <T extends BaseIdentity> Class<? extends T> resolveIdentity(DependencyResolver resolver, Class<T> baseIdentity) {
+ return resolver.resolveIdentity(this, baseIdentity);
+ }
+
+ public <T extends BaseIdentity> void validateIdentity(DependencyResolver resolver, Class<T> baseIdentity, JmxAttribute jmxAttribute) {
+ resolver.validateIdentity(this, baseIdentity, jmxAttribute);
+ }
+
+ @Override
+ public String toString() {
+ final StringBuffer sb = new StringBuffer("IdentityAttributeRef{");
+ sb.append("qNameOfIdentity='").append(qNameOfIdentity).append('\'');
+ sb.append('}');
+ return sb.toString();
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof IdentityAttributeRef)) return false;
+
+ IdentityAttributeRef that = (IdentityAttributeRef) o;
+
+ if (!qNameOfIdentity.equals(that.qNameOfIdentity)) return false;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return qNameOfIdentity.hashCode();
+ }
+
+}
<artifactId>concepts</artifactId>
<version>${yangtools.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-impl</artifactId>
+ <version>${yangtools.version}</version>
+ </dependency>
</dependencies>
<build>
import org.opendaylight.controller.config.manager.impl.util.ModuleQNameUtil;
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.spi.ModuleFactory;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final ModuleFactoriesResolver resolver;
private final MBeanServer configMBeanServer;
+ private final CodecRegistry codecRegistry;
@GuardedBy("this")
private long version = 0;
// constructor
public ConfigRegistryImpl(ModuleFactoriesResolver resolver,
- MBeanServer configMBeanServer) {
+ MBeanServer configMBeanServer, CodecRegistry codecRegistry) {
this(resolver, configMBeanServer,
- new BaseJMXRegistrator(configMBeanServer));
+ new BaseJMXRegistrator(configMBeanServer), codecRegistry);
}
// constructor
public ConfigRegistryImpl(ModuleFactoriesResolver resolver,
MBeanServer configMBeanServer,
- BaseJMXRegistrator baseJMXRegistrator) {
+ BaseJMXRegistrator baseJMXRegistrator, CodecRegistry codecRegistry) {
this.resolver = resolver;
this.beanToOsgiServiceManager = new BeanToOsgiServiceManager();
this.configMBeanServer = configMBeanServer;
this.baseJMXRegistrator = baseJMXRegistrator;
+ this.codecRegistry = codecRegistry;
this.registryMBeanServer = MBeanServerFactory
.createMBeanServer("ConfigRegistry" + configMBeanServer.getDefaultDomain());
this.transactionsMBeanServer = MBeanServerFactory
readableSRRegistry, txLookupRegistry, allCurrentFactories);
ConfigTransactionControllerInternal transactionController = new ConfigTransactionControllerImpl(
- txLookupRegistry, version,
+ txLookupRegistry, version, codecRegistry,
versionCounter, allCurrentFactories, transactionsMBeanServer,
configMBeanServer, blankTransaction, writableRegistry);
try {
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.spi.ModuleFactory;
import org.opendaylight.yangtools.concepts.Identifiable;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final ServiceReferenceWritableRegistry writableSRRegistry;
public ConfigTransactionControllerImpl(ConfigTransactionLookupRegistry txLookupRegistry,
- long parentVersion, long currentVersion,
- Map<String, Map.Entry<ModuleFactory, BundleContext>> currentlyRegisteredFactories,
+ long parentVersion, CodecRegistry codecRegistry, long currentVersion,
+ Map<String, Entry<ModuleFactory, BundleContext>> currentlyRegisteredFactories,
MBeanServer transactionsMBeanServer, MBeanServer configMBeanServer,
boolean blankTransaction, ServiceReferenceWritableRegistry writableSRRegistry) {
-
this.txLookupRegistry = txLookupRegistry;
String transactionName = txLookupRegistry.getTransactionIdentifier().getName();
this.controllerON = ObjectNameUtil.createTransactionControllerON(transactionName);
this.currentlyRegisteredFactories = currentlyRegisteredFactories;
this.factoriesHolder = new HierarchicalConfigMBeanFactoriesHolder(currentlyRegisteredFactories);
this.transactionStatus = new TransactionStatus();
- this.dependencyResolverManager = new DependencyResolverManager(transactionName, transactionStatus, writableSRRegistry);
+ this.dependencyResolverManager = new DependencyResolverManager(transactionName, transactionStatus, writableSRRegistry, codecRegistry);
this.transactionsMBeanServer = transactionsMBeanServer;
this.configMBeanServer = configMBeanServer;
this.blankTransaction = blankTransaction;
package org.opendaylight.controller.config.manager.impl.dependencyresolver;
import org.opendaylight.controller.config.api.DependencyResolver;
+import org.opendaylight.controller.config.api.IdentityAttributeRef;
import org.opendaylight.controller.config.api.JmxAttribute;
import org.opendaylight.controller.config.api.JmxAttributeValidationException;
import org.opendaylight.controller.config.api.ModuleIdentifier;
import org.opendaylight.controller.config.manager.impl.TransactionStatus;
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.spi.ModuleFactory;
+import org.opendaylight.yangtools.yang.binding.BaseIdentity;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
+import org.opendaylight.yangtools.yang.data.impl.codec.IdentityCodec;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import javax.annotation.concurrent.GuardedBy;
import javax.management.ObjectName;
*/
final class DependencyResolverImpl implements DependencyResolver,
Comparable<DependencyResolverImpl> {
+ private static final Logger logger = LoggerFactory.getLogger(DependencyResolverImpl.class);
+
private final ModulesHolder modulesHolder;
private final ModuleIdentifier name;
private final TransactionStatus transactionStatus;
@GuardedBy("this")
private final Set<ModuleIdentifier> dependencies = new HashSet<>();
private final ServiceReferenceReadableRegistry readableRegistry;
+ private final CodecRegistry codecRegistry;
DependencyResolverImpl(ModuleIdentifier currentModule,
- TransactionStatus transactionStatus, ModulesHolder modulesHolder,
- ServiceReferenceReadableRegistry readableRegistry) {
-
+ TransactionStatus transactionStatus, ModulesHolder modulesHolder,
+ ServiceReferenceReadableRegistry readableRegistry, CodecRegistry codecRegistry) {
+ this.codecRegistry = codecRegistry;
this.name = currentModule;
this.transactionStatus = transactionStatus;
this.modulesHolder = modulesHolder;
throw new NullPointerException("Parameter 'jmxAttribute' is null");
JmxAttributeValidationException.checkNotNull(dependentReadOnlyON,
- "is null, " + "expected dependency implementing "
+ "is null, expected dependency implementing "
+ expectedServiceInterface, jmxAttribute);
JmxAttribute jmxAttribute) {
if (expectedType == null || dependentReadOnlyON == null || jmxAttribute == null) {
throw new IllegalArgumentException(format(
- "Null parameters not allowed, got {} {} {}", expectedType,
+ "Null parameters not allowed, got %s %s %s", expectedType,
dependentReadOnlyON, jmxAttribute));
}
dependentReadOnlyON = translateServiceRefIfPossible(dependentReadOnlyON);
}
}
+ @Override
+ public <T extends BaseIdentity> Class<? extends T> resolveIdentity(IdentityAttributeRef identityRef, Class<T> expectedBaseClass) {
+ final QName qName = QName.create(identityRef.getqNameOfIdentity());
+ IdentityCodec<?> identityCodec = codecRegistry.getIdentityCodec();
+ Class<? extends BaseIdentity> deserialized = identityCodec.deserialize(qName);
+ if (deserialized == null) {
+ throw new RuntimeException("Unable to retrieve identity class for " + qName + ", null response from "
+ + codecRegistry);
+ }
+ if (expectedBaseClass.isAssignableFrom(deserialized)) {
+ return (Class<T>) deserialized;
+ } else {
+ logger.error("Cannot resolve class of identity {} : deserialized class {} is not a subclass of {}.",
+ identityRef, deserialized, expectedBaseClass);
+ throw new IllegalArgumentException("Deserialized identity " + deserialized + " cannot be cast to " + expectedBaseClass);
+ }
+ }
+
+ @Override
+ public <T extends BaseIdentity> void validateIdentity(IdentityAttributeRef identityRef, Class<T> expectedBaseClass, JmxAttribute jmxAttribute) {
+ try {
+ resolveIdentity(identityRef, expectedBaseClass);
+ } catch(Exception e) {
+ throw JmxAttributeValidationException.wrap(e, jmxAttribute);
+ }
+ }
+
@Override
public int compareTo(DependencyResolverImpl o) {
transactionStatus.checkCommitted();
.getOrCreate(dependencyName);
if (chainForDetectingCycles2.contains(dependencyName)) {
throw new IllegalStateException(format(
- "Cycle detected, {} contains {}",
+ "Cycle detected, %s contains %s",
chainForDetectingCycles2, dependencyName));
}
int subDepth;
import org.opendaylight.controller.config.manager.impl.TransactionStatus;
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.spi.ModuleFactory;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
import javax.annotation.concurrent.GuardedBy;
import javax.management.InstanceAlreadyExistsException;
private final ModulesHolder modulesHolder;
private final TransactionStatus transactionStatus;
private final ServiceReferenceReadableRegistry readableRegistry;
+ private final CodecRegistry codecRegistry;
public DependencyResolverManager(String transactionName,
- TransactionStatus transactionStatus, ServiceReferenceReadableRegistry readableRegistry) {
+ TransactionStatus transactionStatus, ServiceReferenceReadableRegistry readableRegistry, CodecRegistry codecRegistry) {
this.modulesHolder = new ModulesHolder(transactionName);
this.transactionStatus = transactionStatus;
this.readableRegistry = readableRegistry;
+ this.codecRegistry = codecRegistry;
}
@Override
DependencyResolverImpl dependencyResolver = moduleIdentifiersToDependencyResolverMap.get(name);
if (dependencyResolver == null) {
transactionStatus.checkNotCommitted();
- dependencyResolver = new DependencyResolverImpl(name, transactionStatus, modulesHolder, readableRegistry);
+ dependencyResolver = new DependencyResolverImpl(name, transactionStatus, modulesHolder, readableRegistry, codecRegistry);
moduleIdentifiersToDependencyResolverMap.put(name, dependencyResolver);
}
return dependencyResolver;
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * 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
+ */
+package org.opendaylight.controller.config.manager.impl.osgi;
+
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.osgi.util.tracker.ServiceTrackerCustomizer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Every time factory is added or removed, blank transaction is triggered to handle
+ * {@link org.opendaylight.controller.config.spi.ModuleFactory#getDefaultModules(org.opendaylight.controller.config.api.DependencyResolverFactory, org.osgi.framework.BundleContext)}
+ * functionality.
+ */
+public class BindingIndependentMappingServiceTracker implements ServiceTrackerCustomizer<BindingIndependentMappingService, BindingIndependentMappingService> {
+ private static final Logger logger = LoggerFactory.getLogger(BindingIndependentMappingServiceTracker.class);
+
+ private final ConfigManagerActivator activator;
+ private final BundleContext ctx;
+ private BindingIndependentMappingService service;
+
+ public BindingIndependentMappingServiceTracker(BundleContext context, ConfigManagerActivator activator) {
+ this.ctx = context;
+ this.activator = activator;
+ }
+
+ @Override
+ public synchronized BindingIndependentMappingService addingService(
+ ServiceReference<BindingIndependentMappingService> moduleFactoryServiceReference) {
+
+ if (service != null) {
+ // FIXME
+ // Second registration appears from
+ // org.opendaylight.controller.config.yang.md.sal.binding.impl.RuntimeMappingModule
+ logger.debug("BindingIndependentMappingService was already added as {}" + " now added as {}",
+ service, ctx.getService(moduleFactoryServiceReference));
+ return null;
+ }
+
+ BindingIndependentMappingService service = ctx.getService(moduleFactoryServiceReference);
+ this.service = service;
+ CodecRegistry codecRegistry = service.getCodecRegistry();
+ logger.warn("Codec registry acquired {}", codecRegistry);
+ activator.initConfigManager(ctx, codecRegistry);
+ return service;
+ }
+
+ @Override
+ public void modifiedService(ServiceReference <BindingIndependentMappingService> moduleFactoryServiceReference, BindingIndependentMappingService o) {
+ // TODO crash
+ }
+
+ @Override
+ public void removedService(ServiceReference<BindingIndependentMappingService> moduleFactoryServiceReference, BindingIndependentMappingService o) {
+ // TODO crash
+ }
+}
import java.lang.management.ManagementFactory;
+import javax.management.InstanceAlreadyExistsException;
import javax.management.MBeanServer;
import org.opendaylight.controller.config.manager.impl.ConfigRegistryImpl;
import org.opendaylight.controller.config.manager.impl.jmx.ConfigRegistryJMXRegistrator;
import org.opendaylight.controller.config.spi.ModuleFactory;
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
private ConfigRegistryJMXRegistrator configRegistryJMXRegistrator;
private ServiceRegistration configRegistryServiceRegistration;
+ private ServiceTracker<BindingIndependentMappingService, BindingIndependentMappingService> tracker;
+
@Override
public void start(BundleContext context) throws Exception {
+ BindingIndependentMappingServiceTracker mappingServiceTracker = new BindingIndependentMappingServiceTracker(
+ context, this);
+ tracker = new ServiceTracker<BindingIndependentMappingService, BindingIndependentMappingService>(
+ context, BindingIndependentMappingService.class, mappingServiceTracker);
+
+ logger.debug("Waiting for codec registry");
+
+ tracker.open();
+ }
+
+ void initConfigManager(BundleContext context, CodecRegistry codecRegistry) {
BundleContextBackedModuleFactoriesResolver bundleContextBackedModuleFactoriesResolver =
new BundleContextBackedModuleFactoriesResolver(context);
MBeanServer configMBeanServer = ManagementFactory.getPlatformMBeanServer();
+
+
+ // TODO push codecRegistry/IdentityCodec to dependencyResolver
+
configRegistry = new ConfigRegistryImpl(
- bundleContextBackedModuleFactoriesResolver, configMBeanServer);
+ bundleContextBackedModuleFactoriesResolver, configMBeanServer, codecRegistry);
// register config registry to OSGi
configRegistryServiceRegistration = context.registerService(ConfigRegistryImpl.class, configRegistry, null);
// register config registry to jmx
configRegistryJMXRegistrator = new ConfigRegistryJMXRegistrator(configMBeanServer);
- configRegistryJMXRegistrator.registerToJMX(configRegistry);
+ try {
+ configRegistryJMXRegistrator.registerToJMX(configRegistry);
+ } catch (InstanceAlreadyExistsException e) {
+ throw new RuntimeException("Config Registry was already registered to JMX", e);
+ }
// track bundles containing factories
BlankTransactionServiceTracker blankTransactionServiceTracker = new BlankTransactionServiceTracker(configRegistry);
@Override
public void stop(BundleContext context) throws Exception {
+ try {
+ tracker.close();
+ } catch (Exception e) {
+ logger.warn("Exception while closing tracker", e);
+ }
try {
configRegistry.close();
} catch (Exception e) {
factory, factory);
configRegistry = new ConfigRegistryImpl(resolver,
- ManagementFactory.getPlatformMBeanServer());
+ ManagementFactory.getPlatformMBeanServer(), null);
configRegistry.beginConfig();
fail();
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.util.ConfigRegistryJMXClient;
import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
import org.slf4j.Logger;
baseJmxRegistrator = new BaseJMXRegistrator(internalJmxRegistrator);
configRegistry = new ConfigRegistryImpl(resolver,
- platformMBeanServer, baseJmxRegistrator);
+ platformMBeanServer, baseJmxRegistrator, getCodecRegistry());
try {
configRegistryJMXRegistrator.registerToJMX(configRegistry);
return new ClassBasedModuleFactory(implementationName, configBeanClass);
}
+ protected CodecRegistry getCodecRegistry() {
+ return mock(CodecRegistry.class);
+ }
+
public static interface BundleContextServiceRegistrationHandler {
}
- private class RegisterServiceAnswer implements Answer {
+ private class RegisterServiceAnswer implements Answer<ServiceRegistration<?>> {
@Override
- public Object answer(InvocationOnMock invocation) throws Throwable {
+ public ServiceRegistration<?> answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
Preconditions.checkArgument(args.length == 3, "Unexpected arguments size (expected 3 was %s)", args.length);
@Before
public void setUp() throws Exception {
configRegistryImpl = new ConfigRegistryImpl(null,
- ManagementFactory.getPlatformMBeanServer());
+ ManagementFactory.getPlatformMBeanServer(), null);
Field field = configRegistryImpl.getClass().getDeclaredField(
"baseJMXRegistrator");
field.setAccessible(true);
testedTxController = new ConfigTransactionControllerImpl(
- txLookupRegistry, 1, 1,
+ txLookupRegistry, 1, null, 1,
currentlyRegisteredFactories, transactionsMBeanServer,
ManagementFactory.getPlatformMBeanServer(), false, writableRegistry);
TransactionModuleJMXRegistrator transactionModuleJMXRegistrator123 = testedTxController
public void setUp() {
transactionStatus = mock(TransactionStatus.class);
ServiceReferenceReadableRegistry mockedRegistry = mock(ServiceReferenceReadableRegistry.class);
- tested = new DependencyResolverManager("txName", transactionStatus, mockedRegistry);
+ tested = new DependencyResolverManager("txName", transactionStatus, mockedRegistry, null);
doNothing().when(transactionStatus).checkCommitStarted();
doNothing().when(transactionStatus).checkNotCommitted();
}
<instructions>
<Export-Package>
org.opendaylight.controller.config.shutdown,
- org.opendaylight.controller.config.yang.shutdown
+ org.opendaylight.controller.config.yang.shutdown,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.shutdown.rev131218
</Export-Package>
</instructions>
</configuration>
</dependency>
<dependency>
- <groupId>com.googlecode.slf4j-maven-plugin-log</groupId>
- <artifactId>slf4j-maven-plugin-log</artifactId>
- <version>1.0.0</version>
+ <groupId>com.jcabi</groupId>
+ <artifactId>jcabi-maven-slf4j</artifactId>
+ <version>0.8</version>
</dependency>
<dependency>
@Override
public void setLog(Log log) {
- StaticLoggerBinder.getSingleton().setLog(log);
+ StaticLoggerBinder.getSingleton().setMavenLog(log);
}
private static Map<String, String> extractNamespaceMapping(
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
+import org.opendaylight.controller.config.api.DependencyResolver;
+import org.opendaylight.controller.config.api.IdentityAttributeRef;
import org.opendaylight.controller.config.api.RuntimeBeanRegistratorAwareModule;
import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface;
import org.opendaylight.controller.config.api.runtime.RuntimeBean;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Constructor;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Field;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Header;
+import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.IdentityRefModuleField;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.MethodDeclaration;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.MethodDefinition;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.ModuleField;
import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil;
import org.opendaylight.yangtools.sal.binding.model.api.ParameterizedType;
import org.opendaylight.yangtools.sal.binding.model.api.Type;
+import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
import javax.management.openmbean.SimpleType;
import java.util.ArrayList;
}
// FIXME: put into Type.toString
- static String serializeType(Type type) {
+ static String serializeType(Type type, boolean addWildcards) {
if (type instanceof ParameterizedType){
ParameterizedType parameterizedType = (ParameterizedType) type;
StringBuffer sb = new StringBuffer();
sb.append(parameterizedType.getRawType().getFullyQualifiedName());
- sb.append("<");
+ sb.append(addWildcards ? "<? extends " : "<");
boolean first = true;
for(Type parameter: parameterizedType.getActualTypeArguments()) {
if (first) {
}
}
+ static String serializeType(Type type) {
+ return serializeType(type, false);
+ }
+
+ private static boolean isIdentityRefType(Type type) {
+ return type instanceof IdentityrefTypeDefinition;
+ }
+
private static String getReturnType(AttributeIfc attributeIfc) {
String returnType;
processAttrs(attrs, packageName);
}
+ private final static String dependencyResolverVarName = "dependencyResolver";
+ private final static String dependencyResolverInjectMethodName = "injectDependencyResolver";
+
private void processAttrs(Map<String, AttributeIfc> attrs, String packageName) {
fields = Lists.newArrayList();
methods = Lists.newArrayList();
+ // FIXME conflict if "dependencyResolver" field from yang
+ Field depRes = new Field(DependencyResolver.class.getName(), dependencyResolverVarName);
+ fields.add(depRes);
+ methods.add(new MethodDefinition("void", dependencyResolverInjectMethodName, Lists.newArrayList(depRes),
+ "this." + dependencyResolverVarName + " = " + dependencyResolverVarName + ";"));
+
for (Entry<String, AttributeIfc> attrEntry : attrs.entrySet()) {
String innerName = attrEntry.getKey();
String varName = BindingGeneratorUtil
String fullyQualifiedName, nullableDefault = null;
if (attrEntry.getValue() instanceof TypedAttribute) {
Type type = ((TypedAttribute) attrEntry.getValue()).getType();
- fullyQualifiedName = serializeType(type);
if(attrEntry.getValue() instanceof JavaAttribute) {
nullableDefault = ((JavaAttribute)attrEntry.getValue()).getNullableDefaultWrappedForCode();
+ if(((JavaAttribute)attrEntry.getValue()).isIdentityRef()) {
+
+ String fieldType = serializeType(type, true);
+ String innerType = getInnerTypeFromIdentity(type);
+ methods.add(new MethodDefinition(fieldType, "resolve" + attrEntry.getKey(), Collections.<Field>emptyList(),
+ "return " + varName + ".resolveIdentity(" + dependencyResolverVarName + "," + innerType + ".class);"));
+ type = identityRefType;
+ }
}
+ fullyQualifiedName = serializeType(type);
} else {
fullyQualifiedName = FullyQualifiedNameHelper
.getFullyQualifiedName(packageName, attrEntry.getValue().getUpperCaseCammelCase());
}
- fields.add(new Field(fullyQualifiedName, varName, nullableDefault));
+ fields.add(new Field(fullyQualifiedName, varName, nullableDefault, needsDepResolver(attrEntry.getValue())));
String getterName = "get" + innerName;
MethodDefinition getter = new MethodDefinition(
}
}
+
private static class MXBeanInterfaceAttributesProcessor {
private final List<MethodDeclaration> methods = Lists.newArrayList();
String returnType;
AttributeIfc attributeIfc = attrEntry.getValue();
+ boolean isIdentityRef = false;
if (attributeIfc instanceof TypedAttribute) {
TypedAttribute typedAttribute = (TypedAttribute) attributeIfc;
returnType = serializeType(typedAttribute.getType());
+
+ if (attributeIfc instanceof JavaAttribute && ((JavaAttribute)attrEntry.getValue()).isIdentityRef()) {
+ returnType = serializeType(identityRefType);
+ }
+
} else {
throw new UnsupportedOperationException(
"Attribute not supported: "
MethodDeclaration setter = new MethodDeclaration("void",
setterName, Lists.newArrayList(new Field(returnType,
varName)));
+
methods.add(getter);
methods.add(setter);
}
}
+ private static final Type identityRefType = new Type() {
+ public final Class<IdentityAttributeRef> IDENTITY_ATTRIBUTE_REF_CLASS = IdentityAttributeRef.class;
+
+ @Override
+ public String getPackageName() {
+ return IDENTITY_ATTRIBUTE_REF_CLASS.getPackage().getName();
+ }
+
+ @Override
+ public String getName() {
+ return IDENTITY_ATTRIBUTE_REF_CLASS.getSimpleName();
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return IDENTITY_ATTRIBUTE_REF_CLASS.getName();
+ }
+ };
+
private static class AbstractFactoryAttributesProcessor {
private final List<Field> fields = Lists.newArrayList();
- private static final String STRING_FULLY_QUALIFIED_NAME = "java.util.List";
void processAttributes(Map<String, AttributeIfc> attributes,
String packageName) {
if (attributeIfc instanceof TypedAttribute) {
TypedAttribute typedAttribute = (TypedAttribute) attributeIfc;
type = serializeType(typedAttribute.getType());
- } else if (attributeIfc instanceof TOAttribute) {
- String fullyQualifiedName = FullyQualifiedNameHelper
- .getFullyQualifiedName(packageName, attributeIfc.getUpperCaseCammelCase());
-
- type = fullyQualifiedName;
- } else if (attributeIfc instanceof ListAttribute) { //FIXME: listAttribute might extend TypedAttribute
- String fullyQualifiedName = null;
- AttributeIfc innerAttr = ((ListAttribute) attributeIfc)
- .getInnerAttribute();
- if (innerAttr instanceof JavaAttribute) {
- fullyQualifiedName = ((JavaAttribute) innerAttr)
- .getType().getFullyQualifiedName();
- nullableDefaultWrapped = ((JavaAttribute) innerAttr).getNullableDefaultWrappedForCode();
- } else if (innerAttr instanceof TOAttribute) {
- fullyQualifiedName = FullyQualifiedNameHelper
- .getFullyQualifiedName(packageName, innerAttr.getUpperCaseCammelCase());
- }
-
- type = STRING_FULLY_QUALIFIED_NAME.concat("<")
- .concat(fullyQualifiedName).concat(">");
-
} else {
throw new UnsupportedOperationException(
"Attribute not supported: "
private static class AbstractModuleAttributesProcessor {
- private static final String STRING_FULLY_QUALIFIED_NAME = "java.util.List";
-
private final List<ModuleField> moduleFields = Lists.newArrayList();
private final List<MethodDefinition> methods = Lists.newArrayList();
for (Entry<String, AttributeIfc> attrEntry : attributes.entrySet()) {
String type, nullableDefaultWrapped = null;
AttributeIfc attributeIfc = attrEntry.getValue();
+ boolean isIdentity = false;
+ boolean needsDepResolver = needsDepResolver(attrEntry.getValue());
if (attributeIfc instanceof TypedAttribute) {
TypedAttribute typedAttribute = (TypedAttribute) attributeIfc;
type = serializeType(typedAttribute.getType());
if (attributeIfc instanceof JavaAttribute) {
nullableDefaultWrapped = ((JavaAttribute) attributeIfc).getNullableDefaultWrappedForCode();
+ if(((JavaAttribute)attrEntry.getValue()).isIdentityRef()) {
+ isIdentity = true;
+ type = serializeType(typedAttribute.getType(), true);
+ }
}
-
- } else if (attributeIfc instanceof TOAttribute) {
- String fullyQualifiedName = FullyQualifiedNameHelper
- .getFullyQualifiedName(packageName, attributeIfc.getUpperCaseCammelCase());
-
- type = fullyQualifiedName;
- } else if (attributeIfc instanceof ListAttribute) {
- String fullyQualifiedName = null;
- AttributeIfc innerAttr = ((ListAttribute) attributeIfc)
- .getInnerAttribute();
- if (innerAttr instanceof JavaAttribute) {
- fullyQualifiedName = ((JavaAttribute) innerAttr)
- .getType().getFullyQualifiedName();
- nullableDefaultWrapped = ((JavaAttribute) innerAttr).getNullableDefaultWrappedForCode();
- } else if (innerAttr instanceof TOAttribute) {
- fullyQualifiedName = FullyQualifiedNameHelper
- .getFullyQualifiedName(packageName, innerAttr.getUpperCaseCammelCase());
- }
-
- type = STRING_FULLY_QUALIFIED_NAME.concat("<")
- .concat(fullyQualifiedName).concat(">");
} else {
throw new UnsupportedOperationException(
"Attribute not supported: "
String varName = BindingGeneratorUtil
.parseToValidParamName(attrEntry.getKey());
- moduleFields.add(new ModuleField(type, varName, attributeIfc
- .getUpperCaseCammelCase(), nullableDefaultWrapped, isDependency, dependency, isListOfDependencies));
+
+ ModuleField field;
+
+ if (isIdentity) {
+ String identityBaseClass = getInnerTypeFromIdentity(((TypedAttribute) attributeIfc).getType());
+ IdentityRefModuleField identityField = new IdentityRefModuleField(type, varName,
+ attributeIfc.getUpperCaseCammelCase(), identityBaseClass);
+
+ String getterName = "get"
+ + attributeIfc.getUpperCaseCammelCase() + "Identity";
+ MethodDefinition additionalGetter = new MethodDefinition(type, getterName, Collections.<Field> emptyList(),
+ Collections.<Annotation> emptyList(), "return " + identityField.getIdentityClassName()
+ + ";");
+ methods.add(additionalGetter);
+
+ String setterName = "set"
+ + attributeIfc.getUpperCaseCammelCase();
+
+ String setterBody = "this." + identityField.getIdentityClassName() + " = " + identityField.getIdentityClassName() + ";";
+ MethodDefinition additionalSetter = new MethodDefinition("void",
+ setterName,
+ Lists.newArrayList(new Field(type, identityField.getIdentityClassName())),
+ Collections.<Annotation> emptyList(), setterBody);
+ additionalSetter.setJavadoc(attributeIfc.getNullableDescription());
+
+ methods.add(additionalSetter);
+
+ type = serializeType(identityRefType);
+ field = identityField;
+ } else {
+ field = new ModuleField(type, varName, attributeIfc.getUpperCaseCammelCase(),
+ nullableDefaultWrapped, isDependency, dependency, isListOfDependencies, needsDepResolver);
+ }
+ moduleFields.add(field);
String getterName = "get"
+ attributeIfc.getUpperCaseCammelCase();
MethodDefinition getter = new MethodDefinition(type,
getterName, Collections.<Field> emptyList(),
Lists.newArrayList(overrideAnnotation), "return "
- + varName + ";");
+ + varName + ";");
+
+ methods.add(getter);
String setterName = "set"
+ attributeIfc.getUpperCaseCammelCase();
annotations, setterBody);
setter.setJavadoc(attributeIfc.getNullableDescription());
- methods.add(getter);
methods.add(setter);
}
}
}
+
+ private static boolean needsDepResolver(AttributeIfc value) {
+ if(value instanceof TOAttribute)
+ return true;
+ if(value instanceof ListAttribute) {
+ AttributeIfc innerAttribute = ((ListAttribute) value).getInnerAttribute();
+ return needsDepResolver(innerAttribute);
+ }
+
+ return false;
+ }
+
+ private static String getInnerTypeFromIdentity(Type type) {
+ Preconditions.checkArgument(type instanceof ParameterizedType);
+ Type[] args = ((ParameterizedType) type).getActualTypeArguments();
+ Preconditions.checkArgument(args.length ==1);
+ return serializeType(args[0]);
+ }
}
private final String name;
private final String definition;
private final List<String> modifiers;
+ private final boolean needsDepResolver;
public Field(String type, String name) {
- this(Lists.<String> newArrayList(), type, name, null);
+ this(Lists.<String> newArrayList(), type, name, null, false);
}
public Field(String type, String name, String definition) {
- this(Lists.<String> newArrayList(), type, name, definition);
+ this(Lists.<String> newArrayList(), type, name, definition, false);
}
public Field(List<String> modifiers, String type, String name) {
- this(modifiers, type, name, null);
+ this(modifiers, type, name, null, false);
}
public Field(List<String> modifiers, String type, String name,
String definition) {
+ this(modifiers, type, name, definition, false);
+ }
+
+ public Field(List<String> modifiers, String type, String name,
+ String definition, boolean needsDepResolver) {
this.modifiers = modifiers;
this.type = type;
this.name = name;
this.definition = definition;
+ this.needsDepResolver = needsDepResolver;
+ }
+
+ public Field(String type, String name, String definition, boolean needsDepResolver) {
+ this(Lists.<String> newArrayList(), type, name, definition, needsDepResolver);
+ }
+
+ public boolean isNeedsDepResolver() {
+ return needsDepResolver;
}
public String getType() {
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * 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
+ */
+package org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model;
+
+import org.opendaylight.controller.config.api.IdentityAttributeRef;
+
+public class IdentityRefModuleField extends ModuleField {
+
+ public static final String IDENTITY_CLASS_FIELD_SUFFIX = "IdentityClass";
+ private final String identityBaseClass;
+
+ public IdentityRefModuleField(String type, String name, String attributeName, String identityBaseClass) {
+ super(type, name, attributeName, null, false, null, false, false);
+ this.identityBaseClass = identityBaseClass;
+ }
+
+ public String getIdentityBaseClass() {
+ return identityBaseClass;
+ }
+
+ @Override
+ public boolean isIdentityRef() {
+ return true;
+ }
+
+ public String getType() {
+ return IdentityAttributeRef.class.getName();
+ }
+
+ public String getIdentityClassType() {
+ return super.getType();
+ }
+
+ public String getIdentityClassName() {
+ return addIdentityClassFieldSuffix(getName());
+ }
+
+ public static String addIdentityClassFieldSuffix(String prefix) {
+ return prefix + IDENTITY_CLASS_FIELD_SUFFIX;
+ }
+}
private final boolean dependent, isListOfDependencies;
private final Dependency dependency;
- private ModuleField(List<String> modifiers, String type, String name,
- String attributeName, String nullableDefault, boolean isDependency,
- Dependency dependency, boolean isListOfDependencies) {
- super(modifiers, type, name);
+ private ModuleField(List<String> modifiers, String type, String name, String attributeName, String nullableDefault,
+ boolean isDependency, Dependency dependency, boolean isListOfDependencies, boolean needsDepResolver) {
+ super(modifiers, type, name, null, needsDepResolver);
this.dependent = isDependency;
this.dependency = dependency;
this.attributeName = attributeName;
this.isListOfDependencies = isListOfDependencies;
}
- public ModuleField(String type, String name, String attributeName,
- String nullableDefault, boolean isDependency, Dependency dependency, boolean isListOfDependencies) {
- this(Collections.<String> emptyList(), type, name, attributeName,
- nullableDefault, isDependency, dependency, isListOfDependencies);
+ public ModuleField(String type, String name, String attributeName, String nullableDefault, boolean isDependency,
+ Dependency dependency, boolean isListOfDependencies, boolean needsDepResolve) {
+ this(Collections.<String> emptyList(), type, name, attributeName, nullableDefault, isDependency, dependency,
+ isListOfDependencies, needsDepResolve);
+ }
+
+ public boolean isIdentityRef() {
+ return false;
}
public Dependency getDependency() {
</#if>
</#list>
+ // caches of resolved IdentityRefs
+ <#list moduleFields as field>
+ <#if field.identityRef==true>
+ private ${field.identityClassType} ${field.identityClassName};
+ </#if>
+ </#list>
@Override
public final ${instanceType} getInstance(){
}
</#if>
</#if>
+
+ <#if field.needsDepResolver==true>
+ if(${field.name} != null) {
+ <#if field.type?starts_with("java.util.List")>
+ for(${field.type?substring(field.type?index_of("<") + 1, field.type?index_of(">"))} candidate : ${field.name}) {
+ candidate.injectDependencyResolver(dependencyResolver);
+ }
+ <#else>
+ ${field.name}.injectDependencyResolver(dependencyResolver);
+ </#if>
+ }
+ </#if>
+
+ <#if field.identityRef==true>
+ if(${field.name} != null) {
+ set${field.attributeName}(${field.name}.resolveIdentity(dependencyResolver, ${field.identityBaseClass}.class));
+ }
+ </#if>
</#list>
if(oldInstance!=null && canReuseInstance(oldModule)) {
is(true));
assertThat(peerTO.getFullyQualifiedName(), is(PACKAGE_NAME
+ ".Peer"));
- assertThat(peerTO.getMethods().size(), is(4));
+ assertThat(peerTO.getMethods().size(), is(5));
Method getPort = findFirstMethodByName(peerTO.getMethods(),
"getPort");
assertNotNull(getPort);
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>config-api</artifactId>
- <scope>test</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
package org.opendaylight.controller.config.yangjmxgenerator.attribute;
import com.google.common.base.Preconditions;
+import org.opendaylight.controller.config.api.IdentityAttributeRef;
import org.opendaylight.controller.config.yangjmxgenerator.TypeProviderWrapper;
import org.opendaylight.yangtools.sal.binding.model.api.Type;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import javax.management.openmbean.ArrayType;
TypeProviderWrapper typeProviderWrapper) {
super(leaf);
this.type = typeProviderWrapper.getType(leaf);
+
this.typeDefinition = leaf.getType();
this.typeProviderWrapper = typeProviderWrapper;
this.nullableDefault = leaf.getDefault();
return getCompositeTypeForUnion(baseTypeDefinition);
} else if (isDerivedType(baseType, getType())) {
return getCompositeType(baseType, baseTypeDefinition);
+ } else if (isIdentityRef()) {
+ return getCompositeTypeForIdentity();
}
return getSimpleType(getType());
}
+ public boolean isIdentityRef() {
+ return typeDefinition instanceof IdentityrefTypeDefinition;
+ }
+
private OpenType<?> getCompositeTypeForUnion(TypeDefinition<?> baseTypeDefinition) {
Preconditions.checkArgument(baseTypeDefinition instanceof UnionTypeDefinition,
"Expected %s instance but was %s", UnionTypeDefinition.class, baseTypeDefinition);
}
}
+ public OpenType<?> getCompositeTypeForIdentity() {
+ String[] itemNames = new String[]{IdentityAttributeRef.QNAME_ATTR_NAME};
+ String description = getNullableDescription() == null ? getAttributeYangName() : getNullableDescription();
+ OpenType<?>[] itemTypes = new OpenType[]{SimpleType.STRING};
+
+ try {
+ return new CompositeType(getUpperCaseCammelCase(), description, itemNames, itemNames, itemTypes);
+ } catch (OpenDataException e) {
+ throw new RuntimeException("Unable to create " + CompositeType.class + " with inner element of type "
+ + itemTypes, e);
+ }
+ }
+
private OpenType<?> getArrayType() {
String innerTypeFullyQName = getInnerType(getType());
SimpleType<?> innerSimpleType = SimpleTypeResolver.getSimpleType(innerTypeFullyQName);
}
private boolean isDerivedType(Type baseType, Type currentType) {
- return baseType.equals(currentType) == false;
+ return baseType.equals(currentType) == false;
}
private static String getInnerType(Type type) {
// inconsistent state
inconsistentBundlesToYangURLs.putAll(bundle, addedURLs);
- logger.debug("Yang store is falling back on last consistent state containing {}, inconsistent yang files {}",
+ logger.debug("Yang store is falling back to last consistent state containing {}, inconsistent yang files {}",
consistentBundlesToYangURLs, inconsistentBundlesToYangURLs, failureReason);
- logger.warn("Yang store is falling back on last consistent state containing {} files, inconsistent yang files size is {}, reason {}",
+ logger.info("Yang store is falling back to last consistent state containing {} files, keeping {} inconsistent yang files due to {}",
consistentBundlesToYangURLs.size(), inconsistentBundlesToYangURLs.size(), failureReason.toString());
cache.setInconsistentURLsForReporting(inconsistentBundlesToYangURLs.values());
}
// merge into
consistentBundlesToYangURLs.clear();
consistentBundlesToYangURLs.putAll(proposedNewState);
- inconsistentBundlesToYangURLs.clear();
+
+ logger.debug("Yang store updated to new consistent state containing {}", consistentBundlesToYangURLs);
+
+ // If we cleared up some inconsistent models, report that
+ if (!inconsistentBundlesToYangURLs.isEmpty()) {
+ inconsistentBundlesToYangURLs.clear();
+ logger.info("Yang store updated to new consistent state containing {} yang files", consistentBundlesToYangURLs.size());
+ }
updateCache(snapshot);
cache.setInconsistentURLsForReporting(Collections.<URL> emptySet());
- logger.trace("Yang store updated to new consistent state containing {} yang files", consistentBundlesToYangURLs.size());
- logger.debug("Yang store updated to new consistent state containing {}", consistentBundlesToYangURLs);
}
private synchronized void updateCache(YangStoreSnapshotImpl snapshot) {
</parent>
<artifactId>yang-test</artifactId>
+ <packaging>bundle</packaging>
<description>Artifact that contains only generated code from yang files. Suitable for testing.
</description>
</execution>
</executions>
</plugin>
+
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <configuration>
+ <instructions>
+ </instructions>
+ </configuration>
+ </plugin>
</plugins>
</build>
</project>
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * 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
+ */
+
+package org.opendaylight.controller.config.yang.test.impl;
+
+/**
+*
+*/
+public final class IdentityTestModule extends org.opendaylight.controller.config.yang.test.impl.AbstractIdentityTestModule
+ {
+
+ public IdentityTestModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ super(identifier, dependencyResolver);
+ }
+
+ public IdentityTestModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver,
+ IdentityTestModule oldModule, java.lang.AutoCloseable oldInstance) {
+
+ super(identifier, dependencyResolver, oldModule, oldInstance);
+ }
+
+ @Override
+ protected void customValidation(){
+ // Add custom validation for module attributes here.
+ }
+
+ @Override
+ public java.lang.AutoCloseable createInstance() {
+ System.err.println(getAfi());
+ System.err.println(getAfiIdentity());
+
+ getAfiIdentity();
+ for (Identities identities : getIdentities()) {
+ identities.resolveAfi();
+ identities.resolveSafi();
+ }
+ getIdentitiesContainer().resolveAfi();
+
+ return new AutoCloseable() {
+ @Override
+ public void close() throws Exception {
+ }
+ };
+
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * 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
+ */
+
+package org.opendaylight.controller.config.yang.test.impl;
+
+/**
+*
+*/
+public class IdentityTestModuleFactory extends org.opendaylight.controller.config.yang.test.impl.AbstractIdentityTestModuleFactory
+{
+
+
+}
--- /dev/null
+ System.err.println(getAfi());
+ System.err.println(getAfiIdentity());
+
+ getAfiIdentity();
+ for (Identities identities : getIdentities()) {
+ identities.resolveAfi();
+ identities.resolveSafi();
+ }
+ getIdentitiesContainer().resolveAfi();
+
+ return new AutoCloseable() {
+ @Override
+ public void close() throws Exception {
+ }
+ };
config:java-name-prefix NetconfTestImpl;
}
+ identity impl-identity-test {
+ base config:module-type;
+ config:provided-service test:testing;
+ config:java-name-prefix IdentityTest;
+ }
+
+ identity test-identity1 {
+
+ }
+
+ identity test-identity2 {
+ base test-identity1;
+ }
+
+ augment "/config:modules/config:module/config:configuration" {
+ case impl-identity-test {
+ when "/config:modules/config:module/config:type = 'impl-identity-test'";
+
+ leaf afi {
+ type identityref {
+ base test-identity1;
+ }
+ }
+
+ container identities-container {
+ leaf afi {
+ type identityref {
+ base test-identity1;
+ }
+ }
+ }
+
+ list identities {
+ leaf afi {
+ type identityref {
+ base test-identity1;
+ }
+ }
+ leaf safi {
+ type identityref {
+ base test-identity1;
+ }
+ }
+
+ container identities-inner {
+ leaf afi {
+ type identityref {
+ base test-identity1;
+ }
+ }
+ }
+ }
+
+ }
+ }
+
+ augment "/config:modules/config:module/config:state" {
+ case impl-identity-test {
+ when "/config:modules/config:module/config:type = 'impl-identity-test'";
+
+ }
+ }
+
augment "/config:modules/config:module/config:configuration" {
case impl {
package org.opendaylight.controller.config.yang.test.impl;
import com.google.common.collect.Lists;
+
import junit.framework.Assert;
+
import org.junit.Before;
import org.junit.Test;
+import org.opendaylight.controller.config.api.IdentityAttributeRef;
import org.opendaylight.controller.config.api.jmx.CommitStatus;
import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.test.impl.rev130403.TestIdentity1;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.test.impl.rev130403.TestIdentity2;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
+import org.opendaylight.yangtools.yang.data.impl.codec.IdentityCodec;
import javax.management.InstanceAlreadyExistsException;
import javax.management.ObjectName;
+
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
public class NetconfTestImplModuleTest extends AbstractConfigTest {
factory = new NetconfTestImplModuleFactory();
super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(factory,
- new DepTestImplModuleFactory()));
+ new DepTestImplModuleFactory(), new IdentityTestModuleFactory()));
+ }
+
+ @Override
+ protected CodecRegistry getCodecRegistry() {
+ final IdentityCodec<?> codec = mock(IdentityCodec.class);
+ doReturn(TestIdentity1.class).when(codec).deserialize(TestIdentity1.QNAME);
+ doReturn(TestIdentity2.class).when(codec).deserialize(TestIdentity2.QNAME);
+
+ final CodecRegistry ret = super.getCodecRegistry();
+ doReturn(codec).when(ret).getIdentityCodec();
+ return ret;
+ }
+
+ @Test
+ public void testIdentities() throws Exception {
+ ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
+
+ ObjectName nameCreated = transaction.createModule(IdentityTestModuleFactory.NAME, instanceName);
+ IdentityTestModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, IdentityTestModuleMXBean.class);
+
+ final IdentitiesContainer c = new IdentitiesContainer();
+ c.setAfi(new IdentityAttributeRef(TestIdentity2.QNAME.toString()));
+ mxBean.setIdentitiesContainer(c);
+ transaction.commit();
}
@Test
<version>${yangtools.version}</version>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>clustered-datastore-implementation</artifactId>
- <version>0.4.1-SNAPSHOT</version>
- </dependency>
-
-
<!-- config-->
<dependency>
<groupId>org.opendaylight.controller</groupId>
<groupId>org.opendaylight.controller.thirdparty</groupId>
<artifactId>ganymed</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-remoterpc-connector</artifactId>
- <version>1.0-SNAPSHOT</version>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>
- remoterpc-routingtable.implementation
- </artifactId>
- <version>0.4.1-SNAPSHOT</version>
- </dependency>
<dependency>
<groupId>org.zeromq</groupId>
<artifactId>jeromq</artifactId>
<type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:impl">prefix:hash-map-data-store</type>
<name>hash-map-data-store</name>
</module>
- <module>
- <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:cluster:store">prefix:dom-clustered-store-impl</type>
- <name>cluster-data-store</name>
- </module>
<module>
<type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:impl">prefix:dom-broker-impl</type>
<name>dom-broker</name>
<name>hash-map-data-store</name>
<provider>/modules/module[type='hash-map-data-store'][name='hash-map-data-store']</provider>
</instance>
- <instance>
- <name>cluster-data-store</name>
- <provider>/modules/module[type='dom-clustered-store-impl'][name='cluster-data-store']</provider>
- </instance>
</service>
<service>
<type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
<capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl?module=opendaylight-sal-binding-broker-impl&revision=2013-10-28</capability>
<capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:impl?module=opendaylight-sal-dom-broker-impl&revision=2013-10-28</capability>
<capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:common?module=opendaylight-md-sal-common&revision=2013-10-28</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:cluster:store?module=odl-sal-dom-clustered-store-cfg&revision=2013-10-28</capability>
</required-capabilities>
</snapshot>
+++ /dev/null
-<snapshot>
-
- <configuration>
-
- <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
- <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
- <module>
- <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:remote:rpc">prefix:remote-zeromq-rpc-server</type>
- <name>remoter</name>
- <port xmlns="urn:opendaylight:params:xml:ns:yang:controller:md:sal:remote:rpc">5666</port>
- <dom-broker xmlns="urn:opendaylight:params:xml:ns:yang:controller:md:sal:remote:rpc">
- <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom">prefix:dom-broker-osgi-registry</type>
- <name>dom-broker</name>
- </dom-broker>
- </module>
- </modules>
-
- <services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
- </services>
- </data>
-
- </configuration>
-
- <required-capabilities>
- <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:remote:rpc?module=odl-sal-dom-rpc-remote-cfg&revision=2013-10-28</capability>
- </required-capabilities>
-
-</snapshot>
-
<logger name="org.opendaylight.controller.usermanager" level="INFO"/>
<!-- Web modules -->
<logger name="org.opendaylight.controller.web" level="INFO"/>
+
+ <!--
+ Unsynchronized controller startup causes models to crop up in random
+ order, which results in temporary inability to fully resolve a model,
+ which is usually resolved. Do not flood console, but keep the messages,
+ as they may be indicating and error.
+ -->
+ <logger name="org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort" level="INFO" additivity="false">
+ <appender-ref ref="opendaylight.log"/>
+ </logger>
+
<!-- additivity=false ensures analytics data only goes to the analytics log -->
<logger name="audit" level="INFO" additivity="false">
<appender-ref ref="audit-file"/>
package org.opendaylight.controller.datastore;
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.ops4j.pax.exam.CoreOptions.junitBundles;
+import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
+import static org.ops4j.pax.exam.CoreOptions.options;
+import static org.ops4j.pax.exam.CoreOptions.systemPackages;
+import static org.ops4j.pax.exam.CoreOptions.systemProperty;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import javax.inject.Inject;
+
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.inject.Inject;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-
-import static junit.framework.Assert.assertNotNull;
-import static junit.framework.Assert.assertNull;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.ops4j.pax.exam.CoreOptions.junitBundles;
-import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
-import static org.ops4j.pax.exam.CoreOptions.options;
-import static org.ops4j.pax.exam.CoreOptions.systemPackages;
-import static org.ops4j.pax.exam.CoreOptions.systemProperty;
-
@RunWith(PaxExam.class)
+//@ExamReactorStrategy(PerClass.class)
public class ClusteredDataStoreIT {
private Logger log = LoggerFactory.getLogger(ClusteredDataStoreIT.class);
// get the OSGI bundle context
mavenBundle("org.opendaylight.controller", "sal.implementation").versionAsInProject(),
mavenBundle("org.opendaylight.controller", "protocol_plugins.stub").versionAsInProject(),
- // sal-common-impl
- mavenBundle("org.eclipse.xtend", "org.eclipse.xtend.lib").versionAsInProject(),
- mavenBundle("org.eclipse.xtext", "org.eclipse.xtext.xbase.lib").versionAsInProject(),
-
- // clustered-data-store-implementation dependencies
- mavenBundle("com.google.guava", "guava").versionAsInProject(),
- mavenBundle("org.opendaylight.controller", "sal-core-api").versionAsInProject(),
- mavenBundle("org.opendaylight.controller", "sal-common-api").versionAsInProject(),
- mavenBundle("org.opendaylight.controller", "sal-common-util").versionAsInProject(),
- mavenBundle("org.opendaylight.controller", "sal-common-impl").versionAsInProject(),
- mavenBundle("org.opendaylight.yangtools", "yang-model-api").versionAsInProject(),
- mavenBundle("org.opendaylight.yangtools", "yang-binding").versionAsInProject(),
-
- // sal-common-api dependencies
- mavenBundle("org.opendaylight.controller", "sal-common").versionAsInProject(),
- mavenBundle("org.opendaylight.yangtools", "yang-common").versionAsInProject(),
- mavenBundle("org.opendaylight.yangtools", "concepts").versionAsInProject(),
mavenBundle("org.osgi", "org.osgi.core").versionAsInProject(),
// adding new maven bundles
mavenBundle("org.mockito", "mockito-all").versionAsInProject(),
- // yang-data-api
- mavenBundle("org.opendaylight.yangtools", "yang-data-api").versionAsInProject(),
-
// needed by hosttracker
mavenBundle("org.opendaylight.controller", "clustered-datastore-implementation").versionAsInProject(),
mavenBundle("org.jboss.spec.javax.transaction", "jboss-transaction-api_1.1_spec").versionAsInProject(),
<capability>
urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:cluster:store?module=odl-sal-dom-clustered-store-cfg&revision=2013-10-28
</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom?module=opendaylight-md-sal-dom&revision=2013-10-28</capability>
- <capability>
- urn:opendaylight:params:xml:ns:yang:controller:config?module=config&revision=2013-04-05
- </capability>
- <capability>urn:ietf:params:netconf:capability:candidate:1.0</capability>
- <capability>urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring?module=ietf-netconf-monitoring&revision=2010-10-04</capability>
- <capability>urn:ietf:params:xml:ns:yang:rpc-context?module=rpc-context&revision=2013-06-17
- </capability>
- <capability>urn:ietf:params:xml:ns:yang:ietf-inet-types?module=ietf-inet-types&revision=2010-09-24
- </capability>
- <capability>urn:ietf:params:netconf:capability:rollback-on-error:1.0</capability>
- <capability>urn:ietf:params:xml:ns:yang:ietf-yang-types?module=ietf-yang-types&revision=2010-09-24
- </capability>
- <capability>
- urn:opendaylight:params:xml:ns:yang:controller:md:sal:common?module=opendaylight-md-sal-common&revision=2013-10-28
- </capability>
</required-capabilities>
<configuration>
</encoder>
</appender>
- <root level="info">
+ <root level="debug">
<appender-ref ref="STDOUT" />
</root>
</configuration>
}
static def toFlowConfig(Flow sourceCfg) {
- val flow = toFlow(sourceCfg);
val it = new FlowConfig;
name = String.valueOf(sourceCfg.id);
node = sourceCfg.node.toADNode();
}
override onFlowRemoved(FlowRemoved notification) {
- flowProgrammerPublisher.flowRemoved(notification.node.toADNode,notification.toFlow());
+ if(notification != null && notification.node != null) {
+ val adNode = notification.node.toADNode
+ if(adNode != null) {
+ flowProgrammerPublisher.flowRemoved(adNode,notification.toFlow(adNode));
+ }
+ }
}
override onFlowUpdated(FlowUpdated notification) {
for(flow : table.flow){
- val adsalFlow = ToSalConversionsUtils.toFlow(flow);
+ val adsalFlow = ToSalConversionsUtils.toFlow(flow,node);
val statsFromDataStore = flow.getAugmentation(FlowStatisticsData);
if(statsFromDataStore != null){
for (statsPublisher : statisticsPublisher){
val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance;
- statsPublisher.descriptionStatisticsUpdated(nodeRef.toADNode,toNodeDescription(notification.nodeRef));
+ val description = notification.nodeRef.toNodeDescription
+ if(description != null) {
+ statsPublisher.descriptionStatisticsUpdated(nodeRef.toADNode,description);
+ }
}
}
private def FlowCapableNode readFlowCapableNode(NodeRef ref) {
val dataObject = dataService.readOperationalData(ref.value as InstanceIdentifier<? extends DataObject>);
- val node = dataObject.checkInstanceOf(
- org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node);
- return node.getAugmentation(FlowCapableNode);
+ if(dataObject != null) {
+ val node = dataObject.checkInstanceOf(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node);
+ return node.getAugmentation(FlowCapableNode);
+ }
+ return null;
}
private def FlowCapableNodeConnector readFlowCapableNodeConnector(NodeConnectorRef ref) {
private def toNodeDescription(NodeRef nodeRef){
val capableNode = readFlowCapableNode(nodeRef);
-
- val it = new NodeDescription()
- manufacturer = capableNode.manufacturer
- serialNumber = capableNode.serialNumber
- software = capableNode.software
- description = capableNode.description
-
- return it;
+ if(capableNode !=null) {
+ val it = new NodeDescription()
+ manufacturer = capableNode.manufacturer
+ serialNumber = capableNode.serialNumber
+ software = capableNode.software
+ description = capableNode.description
+
+ return it;
+ }
+ return null;
}
override onFlowsStatisticsUpdate(FlowsStatisticsUpdate notification) {
val adsalFlowsStatistics = new ArrayList<FlowOnNode>();
+ val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance;
for(flowStats : notification.flowAndStatisticsMapList){
if(flowStats.tableId == 0)
- adsalFlowsStatistics.add(toFlowOnNode(flowStats));
+ adsalFlowsStatistics.add(toFlowOnNode(flowStats,nodeRef.toADNode));
}
for (statsPublisher : statisticsPublisher){
- val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance;
statsPublisher.nodeFlowStatisticsUpdated(nodeRef.toADNode,adsalFlowsStatistics);
}
}
- private static def toFlowOnNode (FlowAndStatisticsMapList flowAndStatsMap){
+ private static def toFlowOnNode (FlowAndStatisticsMapList flowAndStatsMap,Node node){
- val it = new FlowOnNode(ToSalConversionsUtils.toFlow(flowAndStatsMap));
+ val it = new FlowOnNode(ToSalConversionsUtils.toFlow(flowAndStatsMap,node));
byteCount = flowAndStatsMap.byteCount.value.longValue;
packetCount = flowAndStatsMap.packetCount.value.longValue;
import org.opendaylight.controller.sal.action.SetVlanId;
import org.opendaylight.controller.sal.action.SetVlanPcp;
import org.opendaylight.controller.sal.action.SwPath;
-import org.opendaylight.controller.sal.core.Capabilities;
+import org.opendaylight.controller.sal.core.ConstructionException;
+import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.NodeConnector;
import org.opendaylight.controller.sal.flowprogrammer.Flow;
import org.opendaylight.controller.sal.match.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv4;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv6;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FeatureCapability;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType;
}
- public static Flow toFlow(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.Flow source) {
+ public static Flow toFlow(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.Flow source, Node node) {
final Flow target = new Flow();
Integer hardTimeout = source.getHardTimeout();
List<Action> actions = getAction(source);
if (actions != null) {
- target.setActions(actionFrom(actions));
+ target.setActions(actionFrom(actions, node));
}
target.setId(source.getCookie().longValue());
return Collections.emptyList();
}
- public static List<org.opendaylight.controller.sal.action.Action> actionFrom(List<Action> actions) {
+ public static List<org.opendaylight.controller.sal.action.Action> actionFrom(List<Action> actions, Node node) {
List<org.opendaylight.controller.sal.action.Action> targetAction = new ArrayList<>();
for (Action action : actions) {
org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action sourceAction = action
Uri nodeConnector = ((OutputActionCase) sourceAction).getOutputAction().getOutputNodeConnector();
if (nodeConnector != null) {
//for (Uri uri : nodeConnectors) {
- targetAction.add(new Output(fromNodeConnectorRef(nodeConnector)));
+ targetAction.add(new Output(fromNodeConnectorRef(nodeConnector, node)));
//}
}
} else if (sourceAction instanceof PopMplsActionCase) {
return null;
}
- private static NodeConnector fromNodeConnectorRef(Uri uri) {
- // TODO: Define mapping
- return null;
+ private static NodeConnector fromNodeConnectorRef(Uri uri, Node node) {
+ NodeConnector nodeConnector = null;
+ try {
+ nodeConnector = new NodeConnector(NodeMapping.MD_SAL_TYPE,node.getNodeIDString()+":"+uri.getValue(),node);
+ } catch (ConstructionException e) {
+ e.printStackTrace();
+ }
+ return nodeConnector;
}
public static Match toMatch(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match source) {
@Override
public Future<RpcResult<AddFlowOutput>> addFlow(AddFlowInput input) {
- Flow flow = ToSalConversionsUtils.toFlow(input);
+ Flow flow = ToSalConversionsUtils.toFlow(input, null);
@SuppressWarnings("unchecked")
org.opendaylight.controller.sal.core.Node node = InventoryMapping.toAdNode((InstanceIdentifier<Node>) input
.getNode().getValue());
@Override
public Future<RpcResult<RemoveFlowOutput>> removeFlow(RemoveFlowInput input) {
- Flow flow = ToSalConversionsUtils.toFlow(input);
+ Flow flow = ToSalConversionsUtils.toFlow(input, null);
@SuppressWarnings("unchecked")
org.opendaylight.controller.sal.core.Node node = InventoryMapping.toAdNode((InstanceIdentifier<Node>) input
.getNode().getValue());
@SuppressWarnings("unchecked")
org.opendaylight.controller.sal.core.Node node = InventoryMapping.toAdNode((InstanceIdentifier<Node>) input
.getNode().getValue());
- Flow originalFlow = ToSalConversionsUtils.toFlow(input.getOriginalFlow());
- Flow updatedFlow = ToSalConversionsUtils.toFlow(input.getUpdatedFlow());
+ Flow originalFlow = ToSalConversionsUtils.toFlow(input.getOriginalFlow(), null);
+ Flow updatedFlow = ToSalConversionsUtils.toFlow(input.getUpdatedFlow(), null);
Status status = delegate.modifyFlowAsync(node, originalFlow, updatedFlow);
UpdateFlowOutputBuilder builder = new UpdateFlowOutputBuilder();
builder.setTransactionId(new TransactionId(BigInteger.valueOf(status.getRequestId())));
try {
Node node = NodeMapping.toADNode(input.getNode());
- Flow flow = ToSalConversionsUtils.toFlow(input);
+ Flow flow = ToSalConversionsUtils.toFlow(input, null);
FlowOnNode readFlow = readDelegate.readFlow(node, flow);
List<FlowAndStatisticsMapList> flowOnNodeToFlowStatistics = new ArrayList<FlowAndStatisticsMapList>();
flowOnNodeToFlowStatistics.add(toOdFlowStatistics(readFlow));
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.CRUDP;
+import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.ETHERNET_ARP;
+import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.TCP;
+import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.UDP;
import java.math.BigInteger;
import java.net.Inet4Address;
import java.util.List;
import org.junit.Test;
-import org.opendaylight.controller.sal.action.*;
+import org.opendaylight.controller.sal.action.Flood;
+import org.opendaylight.controller.sal.action.FloodAll;
+import org.opendaylight.controller.sal.action.HwPath;
+import org.opendaylight.controller.sal.action.Loopback;
+import org.opendaylight.controller.sal.action.Output;
+import org.opendaylight.controller.sal.action.PopVlan;
+import org.opendaylight.controller.sal.action.PushVlan;
+import org.opendaylight.controller.sal.action.SetDlDst;
+import org.opendaylight.controller.sal.action.SetDlSrc;
+import org.opendaylight.controller.sal.action.SetDlType;
+import org.opendaylight.controller.sal.action.SetNextHop;
+import org.opendaylight.controller.sal.action.SetNwDst;
+import org.opendaylight.controller.sal.action.SetNwSrc;
+import org.opendaylight.controller.sal.action.SetNwTos;
+import org.opendaylight.controller.sal.action.SetTpDst;
+import org.opendaylight.controller.sal.action.SetTpSrc;
+import org.opendaylight.controller.sal.action.SetVlanCfi;
+import org.opendaylight.controller.sal.action.SetVlanId;
+import org.opendaylight.controller.sal.action.SetVlanPcp;
+import org.opendaylight.controller.sal.action.SwPath;
import org.opendaylight.controller.sal.compatibility.ToSalConversionsUtils;
+import org.opendaylight.controller.sal.core.ConstructionException;
+import org.opendaylight.controller.sal.core.Node;
+import org.opendaylight.controller.sal.core.Node.NodeIDType;
import org.opendaylight.controller.sal.flowprogrammer.Flow;
import org.opendaylight.controller.sal.match.MatchType;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.*;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Dscp;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowAddedBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.NodeFlow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.VlanCfi;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.*;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.controller.action._case.ControllerActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.drop.action._case.DropActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.flood.action._case.FloodActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.flood.all.action._case.FloodAllActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.hw.path.action._case.HwPathActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.loopback.action._case.LoopbackActionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.ControllerActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DropActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.FloodActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.FloodAllActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.HwPathActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.LoopbackActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopMplsActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopVlanActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushMplsActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushPbbActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushVlanActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetDlDstActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetDlSrcActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetDlTypeActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetMplsTtlActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNextHopActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwDstActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwSrcActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwTosActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwTtlActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetQueueActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetTpDstActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetTpSrcActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanCfiActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanIdActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetVlanPcpActionCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SwPathActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.mpls.action._case.PopMplsActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.vlan.action._case.PopVlanActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.mpls.action._case.PushMplsActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.pbb.action._case.PushPbbActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.vlan.action._case.PushVlanActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.dl.dst.action._case.SetDlDstActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.dl.src.action._case.SetDlSrcActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.dl.type.action._case.SetDlTypeActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.mpls.ttl.action._case.SetMplsTtlActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.next.hop.action._case.SetNextHopActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.nw.dst.action._case.SetNwDstActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.nw.src.action._case.SetNwSrcActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.nw.tos.action._case.SetNwTosActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.nw.ttl.action._case.SetNwTtlActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.queue.action._case.SetQueueActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.tp.dst.action._case.SetTpDstActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.tp.src.action._case.SetTpSrcActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.cfi.action._case.SetVlanCfiActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.id.action._case.SetVlanIdActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.vlan.pcp.action._case.SetVlanPcpActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.sw.path.action._case.SwPathActionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv4Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv6Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowAddedBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.NodeFlow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Instructions;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanPcp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.arp.match.fields.ArpSourceHardwareAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.arp.match.fields.ArpTargetHardwareAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.*;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetDestination;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetDestinationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetSource;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetSourceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetTypeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatch;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatchBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatch;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatchBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer3Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.Layer4Match;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.VlanMatch;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.VlanMatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.ArpMatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6MatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.UdpMatchBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.vlan.match.fields.VlanIdBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
import com.google.common.net.InetAddresses;
-import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.ETHERNET_ARP;
-import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.CRUDP;
-import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.TCP;
-import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.UDP;
-
public class TestToSalConversionsUtils {
// prefix:
// od|Od = Open Daylight
}
@Test
- public void testToSalConversion() {
+ public void testToSalConversion() throws ConstructionException {
FlowAddedBuilder odNodeFlowBuilder = new FlowAddedBuilder();
odNodeFlowBuilder = prepareOdFlowCommon();
-
- Flow salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.other));
+
+ Node node = new Node(NodeIDType.OPENFLOW,(long)1);
+
+ Flow salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.other), node);
checkSalMatch(salFlow.getMatch(), MtchType.other);
- salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.ipv4));
+ salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.ipv4), node);
checkSalMatch(salFlow.getMatch(), MtchType.ipv4);
- salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.ipv6));
+ salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.ipv6), node);
checkSalMatch(salFlow.getMatch(), MtchType.ipv6);
- salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.arp));
+ salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.arp), node);
checkSalMatch(salFlow.getMatch(), MtchType.arp);
- salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.sctp));
+ salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.sctp), node);
checkSalMatch(salFlow.getMatch(), MtchType.sctp);
- salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.tcp));
+ salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.tcp), node);
checkSalMatch(salFlow.getMatch(), MtchType.tcp);
- salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.udp));
+ salFlow = ToSalConversionsUtils.toFlow(prepareOdFlow(odNodeFlowBuilder, MtchType.udp), node);
checkSalMatch(salFlow.getMatch(), MtchType.udp);
checkSalFlow(salFlow);
private void prepareActionOutput(OutputActionCaseBuilder wrapper) {
OutputActionBuilder outputActionBuilder = new OutputActionBuilder();
- outputActionBuilder.setOutputNodeConnector(new Uri("uri1"));
+ outputActionBuilder.setOutputNodeConnector(new Uri("1"));
wrapper.setOutputAction(outputActionBuilder.build());
}
<module>sal-rest-connector</module>
<module>sal-netconf-connector</module>
- <module>remoterpc-routingtable/implementation</module>
- <module>sal-remoterpc-connector/implementation</module>
- <!-- Clustered Data Store -->
- <module>clustered-data-store/implementation</module>
-
+
<module>inventory-manager</module>
<module>statistics-manager</module>
<module>topology-manager</module>
<!-- Compability Packages -->
<module>compatibility</module>
+
+ <!-- Clustering
+ <module>remoterpc-routingtable/implementation</module>
+ <module>sal-remoterpc-connector/implementation</module>
+ <module>clustered-data-store/implementation</module>
+ -->
+
</modules>
</activation>
<modules>
<module>sal-binding-it</module>
- <module>clustered-data-store/integrationtest</module>
+ <!--module>clustered-data-store/integrationtest</module -->
<!--module>zeromq-routingtable/integrationtest</module -->
<!--module>sal-remoterpc-connector/integrationtest</module -->
<!--module>test/sal-rest-connector-it</modulei -->
</property>
</activation>
<build>
- <!-- Put the IDE's build output in a folder other than target,
+ <!-- Put the IDE's build output in a folder other than target,
so that IDE builds don't interact with Maven builds -->
<directory>target-ide</directory>
</build>
<artifactId>maven-bundle-plugin</artifactId>
<version>${bundle.plugin.version}</version>
<extensions>true</extensions>
- <!--executions> <execution> <id>bundle-manifest</id>
- <phase>process-classes</phase> <goals> <goal>manifest</goal> </goals> </execution>
+ <!--executions> <execution> <id>bundle-manifest</id>
+ <phase>process-classes</phase> <goals> <goal>manifest</goal> </goals> </execution>
</executions -->
<configuration>
<instructions>
<artifactId>jacoco-maven-plugin</artifactId>
<version>${jacoco.version}</version>
</plugin>
- <!--This plugin's configuration is used to store Eclipse
+ <!--This plugin's configuration is used to store Eclipse
m2e settings only. It has no influence on the Maven build itself. -->
<plugin>
<groupId>org.eclipse.m2e</groupId>
<phase>generate-sources</phase>
<goals>
<goal>add-source</goal>
+
+
</goals>
<configuration>
<sources>
<configuration>
<instructions>
<Bundle-Name>${project.groupId}.${project.artifactId}</Bundle-Name>
+ <Bundle-Activator>org.opendaylight.controller.sal.binding.osgi.Activator</Bundle-Activator>
<Export-package>
org.opendaylight.controller.sal.binding.spi.*,
</Export-package>
org.opendaylight.controller.sal.binding.codegen,
org.opendaylight.controller.sal.binding.codegen.*,
org.opendaylight.controller.sal.binding.dom.*,
+ org.opendaylight.controller.sal.binding.osgi.*,
</Private-Package>
</instructions>
</configuration>
package org.opendaylight.controller.config.yang.md.sal.binding.impl;\r
\r
import java.util.concurrent.ExecutorService;\r
-import java.util.concurrent.Executors;\r
-import java.util.concurrent.ScheduledExecutorService;\r
\r
-import org.opendaylight.controller.md.sal.common.impl.routing.AbstractDataReadRouter;\r
import org.opendaylight.controller.sal.binding.codegen.impl.SingletonHolder;\r
-import org.opendaylight.controller.sal.binding.impl.DataBrokerImpl;\r
import org.opendaylight.controller.sal.binding.impl.RootDataBrokerImpl;\r
import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingDomConnectorDeployer;\r
import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentConnector;\r
-import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentMappingService;\r
import org.opendaylight.controller.sal.binding.impl.forward.DomForwardedDataBrokerImpl;\r
-import org.opendaylight.controller.sal.core.api.Broker;\r
import org.opendaylight.controller.sal.core.api.Broker.ProviderSession;\r
-import org.opendaylight.controller.sal.core.api.data.DataProviderService;\r
-import org.opendaylight.yangtools.yang.binding.DataObject;\r
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;\r
import org.osgi.framework.BundleContext;\r
-\r
-import com.google.common.util.concurrent.MoreExecutors;\r
+import org.osgi.framework.ServiceReference;\r
\r
/**\r
*\r
@Override\r
public java.lang.AutoCloseable createInstance() {\r
RootDataBrokerImpl dataBindingBroker;\r
- \r
- \r
+\r
+\r
ExecutorService listeningExecutor = SingletonHolder.getDefaultCommitExecutor();\r
- \r
- if (getDomBrokerDependency() != null && getMappingServiceDependency() != null) {\r
- \r
- dataBindingBroker = createDomConnectedBroker(listeningExecutor);\r
+ BindingIndependentMappingService potentialMapping = resolveMappingServiceDependency();\r
+ if (getDomBrokerDependency() != null && potentialMapping != null) {\r
+\r
+ dataBindingBroker = createDomConnectedBroker(listeningExecutor,potentialMapping);\r
} else {\r
dataBindingBroker = createStandAloneBroker(listeningExecutor);\r
}\r
\r
return dataBindingBroker;\r
}\r
+ private BindingIndependentMappingService resolveMappingServiceDependency() {\r
+ if(getMappingService() != null) {\r
+ return getMappingServiceDependency();\r
+ }\r
+ \r
+ ServiceReference<BindingIndependentMappingService> potentialMappingService = bundleContext.getServiceReference(BindingIndependentMappingService.class);\r
+ if(potentialMappingService != null) {\r
+ return bundleContext.getService(potentialMappingService);\r
+ }\r
+ return null;\r
+ }\r
+\r
private RootDataBrokerImpl createStandAloneBroker(ExecutorService listeningExecutor) {\r
RootDataBrokerImpl broker = new RootDataBrokerImpl();\r
broker.setExecutor(listeningExecutor);\r
return broker;\r
}\r
\r
- private RootDataBrokerImpl createDomConnectedBroker(ExecutorService listeningExecutor) {\r
+ private RootDataBrokerImpl createDomConnectedBroker(ExecutorService listeningExecutor, BindingIndependentMappingService mappingService) {\r
DomForwardedDataBrokerImpl forwardedBroker = new DomForwardedDataBrokerImpl();\r
forwardedBroker.setExecutor(listeningExecutor);\r
- BindingIndependentConnector connector = BindingDomConnectorDeployer.createConnector(getMappingServiceDependency());\r
+ BindingIndependentConnector connector = BindingDomConnectorDeployer.createConnector(mappingService);\r
getDomBrokerDependency().registerProvider(forwardedBroker, getBundleContext());\r
ProviderSession domContext = forwardedBroker.getDomProviderContext();\r
forwardedBroker.setConnector(connector);\r
*/
package org.opendaylight.controller.config.yang.md.sal.binding.impl;
+import java.util.Hashtable;
+import java.util.Map.Entry;
+import java.util.Set;
+
import javassist.ClassPool;
import org.opendaylight.controller.sal.binding.codegen.impl.SingletonHolder;
-import org.opendaylight.controller.sal.binding.dom.serializer.impl.RuntimeGeneratedMappingServiceImpl;
+import org.opendaylight.yangtools.concepts.Delegator;
+import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl;
+import org.opendaylight.yangtools.yang.binding.DataContainer;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
+import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
import com.google.common.base.Preconditions;
@Override
public java.lang.AutoCloseable createInstance() {
+
+ RuntimeGeneratedMappingServiceProxy potential = tryToReuseGlobalInstance();
+ if(potential != null) {
+ return potential;
+ }
RuntimeGeneratedMappingServiceImpl service = new RuntimeGeneratedMappingServiceImpl();
service.setPool(SingletonHolder.CLASS_POOL);
- service.start(getBundleContext());
+ service.init();
+ bundleContext.registerService(SchemaServiceListener.class, service, new Hashtable<String,String>());
return service;
}
+ private RuntimeGeneratedMappingServiceProxy tryToReuseGlobalInstance() {
+ ServiceReference<BindingIndependentMappingService> serviceRef = getBundleContext().getServiceReference(BindingIndependentMappingService.class);
+ if(serviceRef == null) {
+ return null;
+ }
+
+ BindingIndependentMappingService delegate = bundleContext.getService(serviceRef);
+ if (delegate == null) {
+ return null;
+ }
+ return new RuntimeGeneratedMappingServiceProxy(getBundleContext(),serviceRef,delegate);
+ }
+
private BundleContext getBundleContext() {
return bundleContext;
}
public void setBundleContext(BundleContext bundleContext) {
this.bundleContext = bundleContext;
}
+
+ private static final class RuntimeGeneratedMappingServiceProxy implements //
+ BindingIndependentMappingService, //
+ Delegator<BindingIndependentMappingService>, //
+ AutoCloseable {
+
+ private BindingIndependentMappingService delegate;
+ private ServiceReference<BindingIndependentMappingService> reference;
+ private BundleContext bundleContext;
+
+ public RuntimeGeneratedMappingServiceProxy(BundleContext bundleContext,
+ ServiceReference<BindingIndependentMappingService> serviceRef,
+ BindingIndependentMappingService delegate) {
+ this.bundleContext = Preconditions.checkNotNull(bundleContext);
+ this.reference = Preconditions.checkNotNull(serviceRef);
+ this.delegate = Preconditions.checkNotNull(delegate);
+ }
+
+ public CodecRegistry getCodecRegistry() {
+ return delegate.getCodecRegistry();
+ }
+
+ public CompositeNode toDataDom(DataObject data) {
+ return delegate.toDataDom(data);
+ }
+
+ public Entry<InstanceIdentifier, CompositeNode> toDataDom(
+ Entry<org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject>, DataObject> entry) {
+ return delegate.toDataDom(entry);
+ }
+
+ public InstanceIdentifier toDataDom(
+ org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject> path) {
+ return delegate.toDataDom(path);
+ }
+
+ public DataObject dataObjectFromDataDom(
+ org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject> path,
+ CompositeNode result) throws DeserializationException {
+ return delegate.dataObjectFromDataDom(path, result);
+ }
+
+ public org.opendaylight.yangtools.yang.binding.InstanceIdentifier<?> fromDataDom(InstanceIdentifier entry)
+ throws DeserializationException {
+ return delegate.fromDataDom(entry);
+ }
+
+ public Set<QName> getRpcQNamesFor(Class<? extends RpcService> service) {
+ return delegate.getRpcQNamesFor(service);
+ }
+
+ public DataContainer dataObjectFromDataDom(Class<? extends DataContainer> inputClass, CompositeNode domInput) {
+ return delegate.dataObjectFromDataDom(inputClass, domInput);
+ }
+
+ @Override
+ public void close() throws Exception {
+ if(delegate != null) {
+ delegate = null;
+ bundleContext.ungetService(reference);
+ bundleContext= null;
+ reference = null;
+ }
+ }
+
+ @Override
+ public BindingIndependentMappingService getDelegate() {
+ return delegate;
+ }
+ }
}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.codegen;
-
-public class CodeGenerationException extends RuntimeException{
-
- public CodeGenerationException() {
- super();
- }
-
- public CodeGenerationException(String message, Throwable cause, boolean enableSuppression,
- boolean writableStackTrace) {
- super(message, cause, enableSuppression, writableStackTrace);
- }
-
- public CodeGenerationException(String message, Throwable cause) {
- super(message, cause);
- }
-
- public CodeGenerationException(String message) {
- super(message);
- }
-
- public CodeGenerationException(Throwable cause) {
- super(cause);
- }
-}
import org.opendaylight.yangtools.yang.binding.annotations.QName
import org.opendaylight.yangtools.yang.binding.DataContainer
import org.opendaylight.yangtools.yang.binding.RpcImplementation
-import org.opendaylight.controller.sal.binding.codegen.util.JavassistUtils
-import org.opendaylight.controller.sal.binding.impl.util.ClassLoaderUtils
+import org.opendaylight.yangtools.sal.binding.generator.util.JavassistUtils
+import org.opendaylight.yangtools.sal.binding.generator.util.ClassLoaderUtils
import javassist.LoaderClassPath
class RuntimeCodeGenerator implements org.opendaylight.controller.sal.binding.codegen.RuntimeCodeGenerator, NotificationInvokerFactory {
val supertype = iface.asCtClass
return supertype.rpcMetadata;
]
-
+
val instance = <T>withClassLoaderAndLock(iface.classLoader,lock) [ |
val supertype = iface.asCtClass
val routerName = iface.routerName;
if(potentialClass != null) {
return potentialClass.newInstance as T;
}
-
+
val targetCls = createClass(iface.routerName, supertype) [
-
-
+
+
field(DELEGATE_FIELD, iface)
//field(REMOTE_INVOKER_FIELD,iface);
implementsType(RpcImplementation.asCtClass)
-
+
for (ctx : metadata.contexts) {
field(ctx.routingTableField, Map)
}
]
]
return targetCls.toClass(iface.classLoader,iface.protectionDomain).newInstance as T
-
+
];
return new RpcRouterCodegenInstance(routerInstanceName,iface, instance, metadata.contexts,metadata.supportedInputs);
}
private def RpcServiceMetadata getRpcMetadata(CtClass iface) {
val metadata = new RpcServiceMetadata;
-
+
iface.methods.filter[declaringClass == iface && parameterTypes.size === 1].forEach [ method |
val routingPair = method.rpcMetadata;
if (routingPair !== null) {
}
private def getRpcMetadata(CtMethod method) {
- val inputClass = method.parameterTypes.get(0);
+ val inputClass = method.parameterTypes.get(0);
return inputClass.rpcMethodMetadata(inputClass,method.name);
}
finalClass as Class<? extends org.opendaylight.controller.sal.binding.api.NotificationListener<?>>);
}
-
+
val newInvoker = generateListenerInvoker(class1);
invokerClasses.put(class1, newInvoker);
return newInvoker
-
+
]
}
}
@Property
val rpcMethods = new HashMap<String, RpcMetadata>();
-
+
@Property
val rpcInputs = new HashMap<Class<? extends DataContainer>, RpcMetadata>();
-
-
+
+
@Property
val supportedInputs = new HashSet<Class<? extends DataContainer>>();
}
@Property
val boolean routeEncapsulated;
-
+
@Property
val CtClass inputType;
}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.codegen.impl;
-
-import java.util.List;
-
-import org.opendaylight.yangtools.yang.binding.BaseIdentity;
-import org.opendaylight.yangtools.yang.binding.RpcService;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-
-public class XtendHelper {
-
- @SuppressWarnings({"rawtypes","unchecked"})
- public static Iterable<TypeDefinition> getTypes(UnionTypeDefinition definition) {
- return (Iterable<TypeDefinition>) (List) definition.getTypes();
- }
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.codegen.util;
-
-import javassist.CtClass;
-
-public interface ClassGenerator {
- void process(CtClass cls);
-}
\ No newline at end of file
+++ /dev/null
-package org.opendaylight.controller.sal.binding.codegen.util;
-
-import javassist.CtField;
-
-public interface FieldGenerator {
- void process(CtField field);
-}
\ No newline at end of file
+++ /dev/null
-package org.opendaylight.controller.sal.binding.codegen.util
-
-import javassist.CtClass
-import javassist.CtMethod
-import javassist.ClassPool
-import java.util.Arrays
-import static com.google.common.base.Preconditions.*;
-import javassist.CtField
-import javassist.Modifier
-import javassist.NotFoundException
-import javassist.LoaderClassPath
-import javassist.ClassClassPath
-import java.util.concurrent.locks.Lock
-import java.util.concurrent.locks.ReentrantLock
-import org.slf4j.LoggerFactory
-import java.util.HashMap
-import java.util.WeakHashMap
-
-class JavassistUtils {
-
- private static val LOG = LoggerFactory.getLogger(JavassistUtils);
-
- private val loaderClassPaths = new WeakHashMap<ClassLoader,LoaderClassPath>();
-
- ClassPool classPool
-
- @Property
- val Lock lock = new ReentrantLock();
-
- new(ClassPool pool) {
- classPool = pool;
- }
-
- def void method(CtClass it, Class<?> returnType, String name, Class<?> parameter, MethodGenerator function1) {
- val method = new CtMethod(returnType.asCtClass, name, Arrays.asList(parameter.asCtClass), it);
- function1.process(method);
- it.addMethod(method);
- }
-
- def void method(CtClass it, Class<?> returnType, String name, Class<?> parameter1, Class<?> parameter2, MethodGenerator function1) {
- val method = new CtMethod(returnType.asCtClass, name, Arrays.asList(parameter1.asCtClass,parameter2.asCtClass), it);
- function1.process(method);
- it.addMethod(method);
- }
-
-
- def void staticMethod(CtClass it, Class<?> returnType, String name, Class<?> parameter, MethodGenerator function1) {
- val method = new CtMethod(returnType.asCtClass, name, Arrays.asList(parameter.asCtClass), it);
- function1.process(method);
- it.addMethod(method);
- }
-
- def void implementMethodsFrom(CtClass target, CtClass source, MethodGenerator function1) {
- for (method : source.methods) {
- if (method.declaringClass == source) {
- val redeclaredMethod = new CtMethod(method, target, null);
- function1.process(redeclaredMethod);
- target.addMethod(redeclaredMethod);
- }
- }
- }
-
- def CtClass createClass(String fqn, ClassGenerator cls) {
-
- val target = classPool.makeClass(fqn);
- cls.process(target);
- return target;
- }
-
- def CtClass createClass(String fqn, CtClass superInterface, ClassGenerator cls) {
-
- val target = classPool.makeClass(fqn);
- target.implementsType(superInterface);
- cls.process(target);
- return target;
- }
-
- def void implementsType(CtClass it, CtClass supertype) {
- checkArgument(supertype.interface, "Supertype must be interface");
- addInterface(supertype);
- }
-
- def asCtClass(Class<?> class1) {
- classPool.get(class1);
- }
-
- def CtField field(CtClass it, String name, Class<?> returnValue) {
- val field = new CtField(returnValue.asCtClass, name, it);
- field.modifiers = Modifier.PUBLIC
- addField(field);
- return field;
- }
-
- def CtField staticField(CtClass it, String name, Class<?> returnValue) {
- val field = new CtField(returnValue.asCtClass, name, it);
- field.modifiers = Modifier.PUBLIC + Modifier.STATIC
- addField(field);
- return field;
- }
-
- def get(ClassPool pool, Class<?> cls) {
- try {
- return pool.get(cls.name)
- } catch (NotFoundException e) {
- appendClassLoaderIfMissing(cls.classLoader)
- try {
- return pool.get(cls.name)
- } catch (NotFoundException ef) {
- LOG.warn("Appending ClassClassPath for {}",cls);
- pool.appendClassPath(new ClassClassPath(cls));
-
- return pool.get(cls.name)
- }
- }
- }
-
- def void appendClassLoaderIfMissing(ClassLoader loader) {
- if(loaderClassPaths.containsKey(loader)) {
- return;
- }
- val ctLoader = new LoaderClassPath(loader);
- classPool.appendClassPath(ctLoader);
- }
-
- def void ensureClassLoader(Class<?> child) {
- appendClassLoaderIfMissing(child.classLoader);
- }
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.codegen.util;
-
-import javassist.CtMethod;
-
-public interface MethodGenerator {
- void process(CtMethod method);
-}
\ No newline at end of file
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.api;
-
-import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.Node;
-
-public interface AugmentationCodec<A extends Augmentation<?>> extends DomCodec<A> {
-
-
- @Override
- public CompositeNode serialize(ValueWithQName<A> input);
-
- @Override
- public ValueWithQName<A> deserialize(Node<?> input);
-
- public QName getAugmentationQName();
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.api;
-
-import org.opendaylight.yangtools.yang.binding.DataContainer;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.Node;
-
-public interface ChoiceCaseCodec<C extends DataContainer> extends DataContainerCodec<C> {
-
- @Override
- public CompositeNode serialize(ValueWithQName<C> input);
-
- @Override
- public ValueWithQName<C> deserialize(Node<?> input);
-
- public boolean isAcceptable(Node<?> input);
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.api;
-
-import org.opendaylight.yangtools.yang.data.api.Node;
-
-public interface ChoiceCodec<C> extends DomCodec<C> {
-
- @Override
- public Node<?> serialize(ValueWithQName<C> input);
-
- @Override
- public ValueWithQName<C> deserialize(Node<?> input);
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.api;
-
-import org.opendaylight.yangtools.concepts.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.binding.BaseIdentity;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-
-import java.util.List;
-
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.IdentifierCodec;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-
-
-public interface CodecRegistry {
-
- InstanceIdentifierCodec getInstanceIdentifierCodec();
-
- IdentitityCodec<?> getIdentityCodec();
-
- <T extends DataContainer> DataContainerCodec<T> getCodecForDataObject(Class<T> object);
-
- <T extends Identifiable<?>> IdentifierCodec<?> getIdentifierCodecForIdentifiable(Class<T> object);
-
- <T extends Identifier<?>> IdentifierCodec<T> getCodecForIdentifier(Class<T> object);
-
- <T extends Augmentation<?>> AugmentationCodec<T> getCodecForAugmentation(Class<T> object);
-
- <T extends BaseIdentity> IdentitityCodec<T> getCodecForIdentity(Class<T> codec);
-
- Class<?> getClassForPath(List<QName> names);
-
- IdentifierCodec<?> getKeyCodecForPath(List<QName> names);
-
-
- void bindingClassEncountered(Class<?> cls);
-
- void putPathToClass(List<QName> names, Class<?> cls);
-
- public abstract QName getQNameForAugmentation(Class<?> cls);
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.api;
-
-import org.opendaylight.yangtools.yang.binding.BindingCodec;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.Node;
-
-public interface DataContainerCodec<T extends DataContainer> extends DomCodec<T> {
-
-
- @Override
- public ValueWithQName<T> deserialize(Node<?> input);
-
- @Override
- public CompositeNode serialize(ValueWithQName<T> input);
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.api;
-
-import org.opendaylight.yangtools.yang.binding.BindingCodec;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.Node;
-
-public interface DomCodec<I> extends BindingCodec<Node<?>, ValueWithQName<I>>{
-
-
- @Override
- public Node<?> serialize(ValueWithQName<I> input);
-
-
- @Override
- public ValueWithQName<I> deserialize(Node<?> input);
-
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.api;
-
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.Node;
-
-public interface IdentifierCodec<I extends Identifier<?>> extends DomCodec<I> {
-
- @Override
- public ValueWithQName<I> deserialize(Node<?> input);
-
- @Override
- public CompositeNode serialize(ValueWithQName<I> input);
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.api;
-
-import org.opendaylight.yangtools.yang.binding.BaseIdentity;
-import org.opendaylight.yangtools.yang.binding.BindingCodec;
-import org.opendaylight.yangtools.yang.common.QName;
-
-public interface IdentitityCodec<T extends BaseIdentity> extends BindingCodec<QName, Class<T>>{
-
- @Override
- public QName serialize(Class<T> input);
-
- @Override
- public Class<T> deserialize(QName input);
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.api;
-
-import org.opendaylight.yangtools.yang.binding.BindingCodec;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public interface InstanceIdentifierCodec extends BindingCodec<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier,InstanceIdentifier<?>> {
-
- @Override
- public org.opendaylight.yangtools.yang.data.api.InstanceIdentifier serialize(InstanceIdentifier<?> input);
-
- @Override
- public InstanceIdentifier<?> deserialize(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier input);
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.api;
-
-import java.util.Map.Entry;
-
-import org.opendaylight.yangtools.yang.common.QName;
-
-public class ValueWithQName<V> implements Entry<QName, V>{
-
- final QName qname;
- final V value;
-
- public ValueWithQName(QName qname, V value) {
- super();
- this.qname = qname;
- this.value = value;
- }
-
- public QName getQname() {
- return qname;
- }
-
- public V getValue() {
- return value;
- }
-
- @Override
- public QName getKey() {
- return qname;
- }
-
- @Override
- public V setValue(V value) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((qname == null) ? 0 : qname.hashCode());
- result = prime * result + ((value == null) ? 0 : value.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- @SuppressWarnings("rawtypes")
- ValueWithQName other = (ValueWithQName) obj;
- if (qname == null) {
- if (other.qname != null)
- return false;
- } else if (!qname.equals(other.qname))
- return false;
- if (value == null) {
- if (other.value != null) {
- return false;
- }
- } else if (!value.equals(other.value)) {
- return false;
- }
- return true;
- }
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.impl;
-
-public interface BindingClassListener {
-
- void onBindingClassCaptured(Class<?> cls);
-
- void onBindingClassProcessed(Class<?> cls);
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.impl;
-
-import java.lang.reflect.Field;
-import java.util.Map;
-
-import org.opendaylight.controller.sal.binding.dom.serializer.api.IdentitityCodec;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.InstanceIdentifierCodec;
-import org.opendaylight.yangtools.yang.binding.BindingCodec;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class CodecMapping {
-
- private static final Logger LOG = LoggerFactory.getLogger(CodecMapping.class);
-
- public static final String INSTANCE_IDENTIFIER_CODEC = "INSTANCE_IDENTIFIER_CODEC";
- public static final String IDENTITYREF_CODEC = "IDENTITYREF_CODEC";
-
- public static final String CLASS_TO_CASE_MAP = "CLASS_TO_CASE";
- public static final String COMPOSITE_TO_CASE = "COMPOSITE_TO_CASE";
- public static final String AUGMENTATION_CODEC = "AUGMENTATION_CODEC";
-
- public static void setIdentifierCodec(Class<?> obj,InstanceIdentifierCodec codec) {
- Field instanceIdField;
- try {
- instanceIdField = obj.getField(INSTANCE_IDENTIFIER_CODEC);
- if(obj != null) {
- instanceIdField.set(null, codec);
- }
- } catch (NoSuchFieldException e) {
- LOG.trace("Instance identifier codec is not needed for {}",obj.getName(),e);
- } catch (SecurityException | IllegalAccessException e) {
- LOG.error("Instance identifier could not be set for {}",obj.getName(),e);
- }
- }
-
-
- public static void setIdentityRefCodec(Class<?> obj,IdentitityCodec<?> codec) {
- Field instanceIdField;
- try {
- instanceIdField = obj.getField(IDENTITYREF_CODEC);
- if(obj != null) {
- instanceIdField.set(null, codec);
- }
- } catch (NoSuchFieldException e) {
- LOG.trace("Instance identifier codec is not needed for {}",obj.getName(),e);
- } catch (SecurityException | IllegalAccessException e) {
- LOG.error("Instance identifier could not be set for {}",obj.getName(),e);
- }
- }
-
- public static void setClassToCaseMap(Class<? extends BindingCodec<?,?>> codec,
- Map<Class<?>,BindingCodec<?,?>> classToCaseRawCodec) {
- Field instanceIdField;
- try {
- instanceIdField = codec.getField(CLASS_TO_CASE_MAP);
- instanceIdField.set(null, classToCaseRawCodec);
- } catch (NoSuchFieldException e) {
- LOG.debug("BUG: Class to case mappping is not needed for {}",codec.getName(),e);
- } catch (SecurityException | IllegalAccessException e) {
- LOG.error("Class to case mappping could not be set for {}",codec.getName(),e);
- }
- }
-
- public static void setCompositeNodeToCaseMap(Class<? extends BindingCodec<?,?>> codec,
- Map<CompositeNode,BindingCodec<?,?>> compositeToCase) {
- Field instanceIdField;
- try {
- instanceIdField = codec.getField(COMPOSITE_TO_CASE);
- instanceIdField.set(null, compositeToCase);
- } catch (NoSuchFieldException e) {
- LOG.debug("BUG: Class to case mappping is not needed for {}",codec.getName(),e);
- } catch (SecurityException | IllegalAccessException e) {
- LOG.error("Composite node to case mappping could not be set for {}",codec.getName(),e);
- }
- }
-
- public static void setAugmentationCodec(Class<? extends BindingCodec<?,?>> dataCodec,
- BindingCodec<?,?> augmentableCodec) {
- Field instanceIdField;
- try {
- instanceIdField = dataCodec.getField(AUGMENTATION_CODEC);
- instanceIdField.set(null, augmentableCodec);
- } catch (NoSuchFieldException e) {
- LOG.debug("BUG: Augmentation codec is not needed for {}",dataCodec.getName(),e);
- } catch (SecurityException | IllegalAccessException e) {
- LOG.error("Augmentation codec could not be set for {}",dataCodec.getName(),e);
- }
- }
-
-
- public static BindingCodec<?,?> getAugmentationCodec(Class<? extends BindingCodec<?,?>> dataCodec) {
- Field instanceIdField;
- try {
- instanceIdField = dataCodec.getField(AUGMENTATION_CODEC);
- return (BindingCodec<?,?>) instanceIdField.get(null);
- } catch (NoSuchFieldException e) {
- LOG.debug("BUG: Augmentation codec is not needed for {}",dataCodec.getName(),e);
- } catch (SecurityException | IllegalAccessException e) {
- LOG.error("Augmentation codec could not be set for {}",dataCodec.getName(),e);
- }
- return null;
- }
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.impl;
-
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
-
-public class CodecTypeUtils {
-
- @SuppressWarnings({"unchecked","rawtypes"})
- public static IdentifiableItem<?, ?> newIdentifiableItem(Class<?> type, Object key) {
- Class<? extends Identifiable<?>> identifiableType = (Class<? extends Identifiable<?>>) type;
- Identifier<? extends Identifiable<?>> identifier = (Identifier<? extends Identifiable<?>>) key;
- return new IdentifiableItem(identifiableType,identifier);
- }
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.impl;
-
-import java.util.Map;
-
-import org.opendaylight.yangtools.yang.binding.BindingCodec;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-
-public interface GeneratorListener {
-
-
-
- void onClassProcessed(Class<?> cl);
-
- void onCodecCreated(Class<?> codec);
- void onValueCodecCreated(Class<?> valueClass,Class<?> valueCodec);
- void onCaseCodecCreated(Class<?> choiceClass,Class<? extends BindingCodec<Map<QName, Object>,Object>> choiceCodec);
- void onDataContainerCodecCreated(Class<?> dataClass, Class<? extends BindingCodec<?,?>> dataCodec);
-
- void onChoiceCodecCreated(Class<?> choiceClass,
- Class<? extends BindingCodec<Map<QName, Object>, Object>> choiceCodec, ChoiceNode schema);
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.impl
-
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
-import org.opendaylight.controller.sal.binding.dom.serializer.api.CodecRegistry
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem
-import org.opendaylight.yangtools.yang.common.QName
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item
-import java.util.Map
-import java.util.WeakHashMap
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates
-import java.util.ArrayList
-import org.opendaylight.controller.sal.binding.dom.serializer.api.InstanceIdentifierCodec
-import org.opendaylight.controller.sal.binding.dom.serializer.api.ValueWithQName
-import java.util.HashMap
-import org.slf4j.LoggerFactory
-import java.util.List
-import org.opendaylight.yangtools.yang.binding.DataObject
-import org.opendaylight.controller.sal.binding.dom.serializer.api.IdentifierCodec
-import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
-import org.opendaylight.yangtools.yang.data.api.Node
-import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
-import org.opendaylight.yangtools.yang.data.api.CompositeNode
-import org.opendaylight.yangtools.yang.binding.Augmentable
-import com.google.common.collect.ImmutableList
-import org.opendaylight.yangtools.yang.binding.Augmentation
-import java.util.concurrent.ConcurrentHashMap
-import org.opendaylight.yangtools.yang.binding.util.BindingReflections
-
-class InstanceIdentifierCodecImpl implements InstanceIdentifierCodec {
-
- private static val LOG = LoggerFactory.getLogger(InstanceIdentifierCodecImpl);
- val CodecRegistry codecRegistry;
-
- val Map<Class<?>, Map<List<QName>, Class<?>>> classToPreviousAugment = new WeakHashMap;
-
- public new(CodecRegistry registry) {
- codecRegistry = registry;
- }
-
-
- override deserialize(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier input) {
- var Class<?> baType = null
- val biArgs = input.path
- val scannedPath = new ArrayList<QName>(biArgs.size);
- val baArgs = new ArrayList<org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument>(biArgs.size)
- for(biArg : biArgs) {
- scannedPath.add(biArg.nodeType);
- val baArg = deserializePathArgument(biArg,scannedPath)
- baType = baArg?.type
- val injectAugment = classToPreviousAugment.get(baType);
- if(injectAugment != null) {
- val augment = injectAugment.get(scannedPath) as Class<? extends DataObject>;
- if(augment != null) {
- baArgs.add(new Item(augment));
- }
- }
- baArgs.add(baArg)
- }
- val ret = new InstanceIdentifier(baArgs,baType as Class<? extends DataObject>);
- LOG.debug("DOM Instance Identifier {} deserialized to {}",input,ret);
- return ret;
- }
-
- private def dispatch org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument deserializePathArgument(NodeIdentifier argument,List<QName> processedPath) {
- val Class cls = codecRegistry.getClassForPath(processedPath);
- return new Item(cls);
- }
-
-
- private def dispatch org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument deserializePathArgument(NodeIdentifierWithPredicates argument,List<QName> processedPath) {
- val Class type = codecRegistry.getClassForPath(processedPath);
- val IdentifierCodec codec = codecRegistry.getIdentifierCodecForIdentifiable(type);
- val value = codec.deserialize(argument.toCompositeNode())?.value;
- return CodecTypeUtils.newIdentifiableItem(type,value);
- }
-
- def CompositeNode toCompositeNode(NodeIdentifierWithPredicates predicates) {
- val keyValues = predicates.keyValues.entrySet;
- val values = new ArrayList<Node<?>>(keyValues.size)
- for(keyValue : keyValues) {
- values.add(new SimpleNodeTOImpl(keyValue.key,null,keyValue.value))
- }
- return new CompositeNodeTOImpl(predicates.nodeType,null,values);
- }
-
- override serialize(InstanceIdentifier input) {
- var Class<?> previousAugmentation = null
- val pathArgs = input.path as List<org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument>
- var QName previousQName = null;
- val components = new ArrayList<PathArgument>(pathArgs.size);
- val qnamePath = new ArrayList<QName>(pathArgs.size);
- for(baArg : pathArgs) {
-
- if(!Augmentation.isAssignableFrom(baArg.type)) {
-
- val biArg = serializePathArgument(baArg,previousQName);
- previousQName = biArg.nodeType;
- components.add(biArg);
- qnamePath.add(biArg.nodeType);
- val immutableList = ImmutableList.copyOf(qnamePath);
- codecRegistry.putPathToClass(immutableList,baArg.type);
- if(previousAugmentation !== null) {
- updateAugmentationInjection(baArg.type,immutableList,previousAugmentation)
- }
-
- previousAugmentation = null;
- } else {
- previousQName = codecRegistry.getQNameForAugmentation(baArg.type as Class);
- previousAugmentation = baArg.type;
- }
- }
- val ret = new org.opendaylight.yangtools.yang.data.api.InstanceIdentifier(components);
- LOG.debug("Binding Instance Identifier {} serialized to DOM InstanceIdentifier {}",input,ret);
- return ret;
- }
-
- def updateAugmentationInjection(Class<? extends DataObject> class1, ImmutableList<QName> list, Class<?> augmentation) {
- if(classToPreviousAugment.get(class1) == null) {
- classToPreviousAugment.put(class1,new ConcurrentHashMap());
- }
- classToPreviousAugment.get(class1).put(list,augmentation);
- }
-
- private def dispatch PathArgument serializePathArgument(Item argument, QName previousQname) {
- val type = argument.type;
- val qname = BindingReflections.findQName(type);
- if(previousQname == null) {
- return new NodeIdentifier(qname);
- }
- return new NodeIdentifier(QName.create(previousQname,qname.localName));
- }
-
- @SuppressWarnings("rawtypes")
- private def dispatch PathArgument serializePathArgument(IdentifiableItem argument, QName previousQname) {
- val Map<QName,Object> predicates = new HashMap();
- val type = argument.type;
- val keyCodec = codecRegistry.getIdentifierCodecForIdentifiable(type);
- val qname = BindingReflections.findQName(type);
- val combinedInput = new ValueWithQName(previousQname,argument.key)
- val compositeOutput = keyCodec.serialize(combinedInput as ValueWithQName);
- for(outputValue :compositeOutput.value) {
- predicates.put(outputValue.nodeType,outputValue.value);
- }
- if(previousQname == null) {
- return new NodeIdentifierWithPredicates(qname,predicates);
- }
- return new NodeIdentifierWithPredicates(QName.create(previousQname,qname.localName),predicates);
- }
-}
\ No newline at end of file
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.impl
-
-import org.opendaylight.yangtools.yang.data.api.Node
-import java.util.Map
-import org.opendaylight.yangtools.yang.common.QName
-import java.util.List
-import java.util.ArrayList
-import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
-import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
-import com.google.common.base.Preconditions
-
-class IntermediateMapping {
-
-
-
- static def Node<?> toNode(Map<?,?> map) {
- if(map instanceof Node<?>) {
- return map as Node<?>;
- }
- val nodeMap = map as Map<QName,Object>;
- Preconditions.checkArgument(map.size == 1);
- val elem = nodeMap.entrySet.iterator.next;
- val qname = elem.key;
- val value = elem.value;
- toNodeImpl(qname, value);
- }
-
-
- static def dispatch Node<?> toNodeImpl(QName name, List<?> objects) {
- val values = new ArrayList<Node<?>>(objects.size);
- for (obj : objects) {
- if(obj instanceof Node<?>) {
- values.add(obj as Node<?>);
- } else if(obj instanceof Map<?,?>) {
- values.add(toNode(obj as Map<?,?>));
- }
- }
- return new CompositeNodeTOImpl(name, null, values);
- }
-
- static def dispatch Node<?> toNodeImpl(QName name, Map<QName, Object> object) {
- throw new UnsupportedOperationException("Unsupported node hierarchy.");
- }
-
- static def dispatch Node<?> toNodeImpl(QName name, Object object) {
- return new SimpleNodeTOImpl(name, null, object);
- }
-}
\ No newline at end of file
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.impl;
-
-import java.awt.CompositeContext;
-import java.lang.ref.WeakReference;
-import java.lang.reflect.Field;
-import java.lang.reflect.ParameterizedType;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.Set;
-import java.util.WeakHashMap;
-
-import org.apache.commons.lang3.text.translate.AggregateTranslator;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.AugmentationCodec;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.ChoiceCaseCodec;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.ChoiceCodec;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.CodecRegistry;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.DataContainerCodec;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.DomCodec;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.IdentifierCodec;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.IdentitityCodec;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.InstanceIdentifierCodec;
-import org.opendaylight.controller.sal.binding.dom.serializer.api.ValueWithQName;
-import org.opendaylight.controller.sal.binding.impl.util.ClassLoaderUtils;
-import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener;
-import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl;
-import org.opendaylight.yangtools.binding.generator.util.Types;
-import org.opendaylight.yangtools.concepts.Delegator;
-import org.opendaylight.yangtools.concepts.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Augmentable;
-import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.binding.BaseIdentity;
-import org.opendaylight.yangtools.yang.binding.BindingCodec;
-import org.opendaylight.yangtools.yang.binding.DataContainer;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.Node;
-import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static com.google.common.base.Preconditions.*;
-import static org.opendaylight.controller.sal.binding.dom.serializer.impl.IntermediateMapping.*;
-
-import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleContext;
-import org.opendaylight.yangtools.sal.binding.model.api.ConcreteType;
-import org.opendaylight.yangtools.sal.binding.model.api.Type;
-import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
-import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
-
-import com.google.common.collect.FluentIterable;
-import com.google.common.util.concurrent.CycleDetectingLockFactory.WithExplicitOrdering;
-
-public class LazyGeneratedCodecRegistry implements //
- CodecRegistry, //
- SchemaServiceListener, //
- GeneratorListener {
-
- private final static Logger LOG = LoggerFactory.getLogger(LazyGeneratedCodecRegistry.class);
- private final static LateMixinCodec NOT_READY_CODEC = new LateMixinCodec();
-
- private final InstanceIdentifierCodec instanceIdentifierCodec = new InstanceIdentifierCodecImpl(this);
- private final IdentityCompositeCodec identityRefCodec = new IdentityCompositeCodec();
-
- private TransformerGenerator generator;
-
- // Concrete class to codecs
- private static final Map<Class<?>, DataContainerCodec<?>> containerCodecs = new WeakHashMap<>();
- private static final Map<Class<?>, IdentifierCodec<?>> identifierCodecs = new WeakHashMap<>();
- private static final Map<Class<?>, ChoiceCodecImpl<?>> choiceCodecs = new WeakHashMap<>();
- private static final Map<Class<?>, ChoiceCaseCodecImpl<?>> caseCodecs = new WeakHashMap<>();
- private static final Map<Class<?>, AugmentableCompositeCodec> augmentableCodecs = new WeakHashMap<>();
- private static final Map<Class<?>, AugmentationCodec<?>> augmentationCodecs = new WeakHashMap<>();
- private static final Map<Class<?>, QName> identityQNames = new WeakHashMap<>();
- private static final Map<QName, Type> qnamesToIdentityMap = new ConcurrentHashMap<>();
- /** Binding type to encountered classes mapping **/
- @SuppressWarnings("rawtypes")
- private static final Map<Type, WeakReference<Class>> typeToClass = new ConcurrentHashMap<>();
-
- @SuppressWarnings("rawtypes")
- private static final ConcurrentMap<Type, ChoiceCaseCodecImpl> typeToCaseCodecs = new ConcurrentHashMap<>();
-
- private CaseClassMapFacade classToCaseRawCodec = new CaseClassMapFacade();
-
- private static final Map<SchemaPath, GeneratedTypeBuilder> pathToType = new ConcurrentHashMap<>();
- private static final Map<List<QName>, Type> pathToInstantiatedType = new ConcurrentHashMap<>();
- private static final Map<Type, QName> typeToQname = new ConcurrentHashMap<>();
-
- private SchemaContext currentSchema;
-
- public TransformerGenerator getGenerator() {
- return generator;
- }
-
- public void setGenerator(TransformerGenerator generator) {
- this.generator = generator;
- }
-
- @Override
- public InstanceIdentifierCodec getInstanceIdentifierCodec() {
- return instanceIdentifierCodec;
- }
-
- @Override
- public <T extends Augmentation<?>> AugmentationCodec<T> getCodecForAugmentation(Class<T> object) {
- AugmentationCodec<T> codec = null;
- @SuppressWarnings("rawtypes")
- AugmentationCodec potentialCodec = augmentationCodecs.get(object);
- if (potentialCodec != null) {
- codec = potentialCodec;
- } else
- try {
- Class<? extends BindingCodec<Map<QName, Object>, Object>> augmentRawCodec = generator
- .augmentationTransformerFor(object);
- BindingCodec<Map<QName, Object>, Object> rawCodec = augmentRawCodec.newInstance();
- codec = new AugmentationCodecWrapper<T>(rawCodec);
- augmentationCodecs.put(augmentRawCodec, codec);
- } catch (InstantiationException e) {
- LOG.error("Can not instantiate raw augmentation codec {}", object.getSimpleName(), e);
- } catch (IllegalAccessException e) {
- LOG.debug("BUG: Constructor for {} is not accessible.", object.getSimpleName(), e);
- }
- Class<? extends Augmentable<?>> objectSupertype = getAugmentableArgumentFrom(object);
- if (objectSupertype != null) {
- getAugmentableCodec(objectSupertype).addAugmentationCodec(object, codec);
- } else {
- LOG.warn("Could not find augmentation target for augmentation {}", object);
- }
- return codec;
- }
-
- @Override
- public QName getQNameForAugmentation(Class<?> cls) {
- checkArgument(Augmentation.class.isAssignableFrom(cls));
- return getCodecForAugmentation((Class<? extends Augmentation>)cls).getAugmentationQName();
- }
-
- private static Class<? extends Augmentable<?>> getAugmentableArgumentFrom(
- final Class<? extends Augmentation<?>> augmentation) {
- try {
- Class<? extends Augmentable<?>> ret = ClassLoaderUtils.withClassLoader(augmentation.getClassLoader(),
- new Callable<Class<? extends Augmentable<?>>>() {
- @Override
- @SuppressWarnings("unchecked")
- public Class<? extends Augmentable<?>> call() throws Exception {
- for (java.lang.reflect.Type supertype : augmentation.getGenericInterfaces()) {
- if (supertype instanceof ParameterizedType
- && Augmentation.class.equals(((ParameterizedType) supertype).getRawType())) {
- ParameterizedType augmentationGeneric = (ParameterizedType) supertype;
- return (Class<? extends Augmentable<?>>) augmentationGeneric
- .getActualTypeArguments()[0];
- }
- }
- return null;
- }
- });
- return ret;
- } catch (Exception e) {
- LOG.debug("Could not find augmentable for {} using {}", augmentation, augmentation.getClassLoader(), e);
- return null;
- }
- }
-
- @Override
- public Class<?> getClassForPath(List<QName> names) {
- DataSchemaNode node = getSchemaNode(names);
- SchemaPath path = node.getPath();
- Type type = pathToType.get(path);
- if (type != null) {
- type = new ReferencedTypeImpl(type.getPackageName(), type.getName());
- } else {
- type = pathToInstantiatedType.get(names);
- }
- @SuppressWarnings("rawtypes")
- WeakReference<Class> weakRef = typeToClass.get(type);
- if (weakRef == null) {
- LOG.error("Could not find loaded class for path: {} and type: {}", path, type.getFullyQualifiedName());
- }
- return weakRef.get();
- }
-
- @Override
- public void putPathToClass(List<QName> names, Class<?> cls) {
- Type reference = Types.typeForClass(cls);
- pathToInstantiatedType.put(names, reference);
- bindingClassEncountered(cls);
- }
-
- @Override
- public IdentifierCodec<?> getKeyCodecForPath(List<QName> names) {
- @SuppressWarnings("unchecked")
- Class<? extends Identifiable<?>> cls = (Class<? extends Identifiable<?>>) getClassForPath(names);
- return getIdentifierCodecForIdentifiable(cls);
- }
-
- @Override
- public <T extends DataContainer> DataContainerCodec<T> getCodecForDataObject(Class<T> type) {
- @SuppressWarnings("unchecked")
- DataContainerCodec<T> ret = (DataContainerCodec<T>) containerCodecs.get(type);
- if (ret != null) {
- return ret;
- }
- Class<? extends BindingCodec<Map<QName, Object>, Object>> newType = generator.transformerFor(type);
- BindingCodec<Map<QName, Object>, Object> rawCodec = newInstanceOf(newType);
- DataContainerCodecImpl<T> newWrapper = new DataContainerCodecImpl<>(rawCodec);
- containerCodecs.put(type, newWrapper);
- return newWrapper;
- }
-
- @SuppressWarnings("rawtypes")
- public void bindingClassEncountered(Class cls) {
-
- ConcreteType typeRef = Types.typeForClass(cls);
- if (typeToClass.containsKey(typeRef)) {
- return;
- }
- LOG.trace("Binding Class {} encountered.", cls);
- WeakReference<Class> weakRef = new WeakReference<>(cls);
- typeToClass.put(typeRef, weakRef);
- if (Augmentation.class.isAssignableFrom(cls)) {
-
- } else if (DataObject.class.isAssignableFrom(cls)) {
- @SuppressWarnings({ "unchecked", "unused" })
- Object cdc = getCodecForDataObject((Class<? extends DataObject>) cls);
- }
- }
-
- @Override
- public void onClassProcessed(Class<?> cls) {
- ConcreteType typeRef = Types.typeForClass(cls);
- if (typeToClass.containsKey(typeRef)) {
- return;
- }
- LOG.trace("Binding Class {} encountered.", cls);
- WeakReference<Class> weakRef = new WeakReference<>((Class) cls);
- typeToClass.put(typeRef, weakRef);
- }
-
- private DataSchemaNode getSchemaNode(List<QName> path) {
- QName firstNode = path.get(0);
- DataNodeContainer previous = currentSchema.findModuleByNamespaceAndRevision(firstNode.getNamespace(),
- firstNode.getRevision());
- Iterator<QName> iterator = path.iterator();
- while (iterator.hasNext()) {
- QName arg = iterator.next();
- DataSchemaNode currentNode = previous.getDataChildByName(arg);
- if (currentNode == null && previous instanceof DataNodeContainer) {
- currentNode = searchInChoices(previous, arg);
- }
- if (currentNode instanceof DataNodeContainer) {
- previous = (DataNodeContainer) currentNode;
- } else if (currentNode instanceof LeafSchemaNode || currentNode instanceof LeafListSchemaNode) {
- checkState(!iterator.hasNext(), "Path tries to nest inside leaf node.");
- return currentNode;
- }
- }
- return (DataSchemaNode) previous;
- }
-
- private DataSchemaNode searchInChoices(DataNodeContainer node, QName arg) {
- Set<DataSchemaNode> children = node.getChildNodes();
- for (DataSchemaNode child : children) {
- if (child instanceof ChoiceNode) {
- ChoiceNode choiceNode = (ChoiceNode) child;
- DataSchemaNode potential = searchInCases(choiceNode, arg);
- if (potential != null) {
- return potential;
- }
- }
- }
- return null;
- }
-
- private DataSchemaNode searchInCases(ChoiceNode choiceNode, QName arg) {
- Set<ChoiceCaseNode> cases = choiceNode.getCases();
- for (ChoiceCaseNode caseNode : cases) {
- DataSchemaNode node = caseNode.getDataChildByName(arg);
- if (node != null) {
- return node;
- }
- }
- return null;
- }
-
- private <T> T newInstanceOf(Class<?> newType) {
- try {
- @SuppressWarnings("unchecked")
- T ret = (T) newType.newInstance();
- return ret;
- } catch (InstantiationException e) {
- throw new IllegalStateException(e);
- } catch (IllegalAccessException e) {
- throw new IllegalStateException(e);
- }
- }
-
- @Override
- public <T extends Identifiable<?>> IdentifierCodec<?> getIdentifierCodecForIdentifiable(Class<T> type) {
- IdentifierCodec<?> obj = identifierCodecs.get(type);
- if (obj != null) {
- return obj;
- }
- Class<? extends BindingCodec<Map<QName, Object>, Object>> newCodec = generator
- .keyTransformerForIdentifiable(type);
- BindingCodec<Map<QName, Object>, Object> newInstance;
- newInstance = newInstanceOf(newCodec);
- IdentifierCodecImpl<?> newWrapper = new IdentifierCodecImpl<>(newInstance);
- identifierCodecs.put(type, newWrapper);
- return newWrapper;
- }
-
- @Override
- public IdentitityCodec<?> getIdentityCodec() {
- return identityRefCodec;
- }
-
- @Override
- public <T extends BaseIdentity> IdentitityCodec<T> getCodecForIdentity(Class<T> codec) {
- bindingClassEncountered(codec);
- return identityRefCodec;
- }
-
- @Override
- public void onCodecCreated(Class<?> cls) {
- CodecMapping.setIdentifierCodec(cls, instanceIdentifierCodec);
- CodecMapping.setIdentityRefCodec(cls, identityRefCodec);
- }
-
- @Override
- public <T extends Identifier<?>> IdentifierCodec<T> getCodecForIdentifier(Class<T> object) {
- @SuppressWarnings("unchecked")
- IdentifierCodec<T> obj = (IdentifierCodec<T>) identifierCodecs.get(object);
- if (obj != null) {
- return obj;
- }
- Class<? extends BindingCodec<Map<QName, Object>, Object>> newCodec = generator
- .keyTransformerForIdentifier(object);
- BindingCodec<Map<QName, Object>, Object> newInstance;
- newInstance = newInstanceOf(newCodec);
- IdentifierCodecImpl<T> newWrapper = new IdentifierCodecImpl<>(newInstance);
- identifierCodecs.put(object, newWrapper);
- return newWrapper;
- }
-
- @SuppressWarnings("rawtypes")
- public ChoiceCaseCodecImpl getCaseCodecFor(Class caseClass) {
- ChoiceCaseCodecImpl<?> potential = caseCodecs.get(caseClass);
- if (potential != null) {
- return potential;
- }
- ConcreteType typeref = Types.typeForClass(caseClass);
- ChoiceCaseCodecImpl caseCodec = typeToCaseCodecs.get(typeref);
-
- checkState(caseCodec != null, "Case Codec was not created proactivelly for %s", caseClass.getName());
- checkState(caseCodec.getSchema() != null, "Case schema is not available for %s", caseClass.getName());
- @SuppressWarnings("unchecked")
- Class<? extends BindingCodec> newCodec = generator.caseCodecFor(caseClass, caseCodec.getSchema());
- BindingCodec newInstance = newInstanceOf(newCodec);
- caseCodec.setDelegate(newInstance);
- caseCodecs.put(caseClass, caseCodec);
-
- for (Entry<Class<?>, ChoiceCodecImpl<?>> choice : choiceCodecs.entrySet()) {
- if (choice.getKey().isAssignableFrom(caseClass)) {
- choice.getValue().cases.put(caseClass, caseCodec);
- }
- }
- return caseCodec;
- }
-
- public void onModuleContextAdded(SchemaContext schemaContext, Module module, ModuleContext context) {
- pathToType.putAll(context.getChildNodes());
- qnamesToIdentityMap.putAll(context.getIdentities());
- for (Entry<QName, GeneratedTOBuilder> identity : context.getIdentities().entrySet()) {
- typeToQname.put(
- new ReferencedTypeImpl(identity.getValue().getPackageName(), identity.getValue().getName()),
- identity.getKey());
- }
- captureCases(context.getCases(), schemaContext);
- }
-
- private void captureCases(Map<SchemaPath, GeneratedTypeBuilder> cases, SchemaContext module) {
- for (Entry<SchemaPath, GeneratedTypeBuilder> caseNode : cases.entrySet()) {
- ReferencedTypeImpl typeref = new ReferencedTypeImpl(caseNode.getValue().getPackageName(), caseNode
- .getValue().getName());
-
- pathToType.put(caseNode.getKey(), caseNode.getValue());
-
- ChoiceCaseNode node = (ChoiceCaseNode) SchemaContextUtil.findDataSchemaNode(module, caseNode.getKey());
-
- if (node == null) {
- LOG.error("YANGTools Bug: SchemaNode for {}, with path {} was not found in context.",
- typeref.getFullyQualifiedName(), caseNode.getKey());
- @SuppressWarnings("rawtypes")
- ChoiceCaseCodecImpl value = new ChoiceCaseCodecImpl();
- typeToCaseCodecs.putIfAbsent(typeref, value);
- continue;
- }
- @SuppressWarnings("rawtypes")
- ChoiceCaseCodecImpl value = new ChoiceCaseCodecImpl(node);
- typeToCaseCodecs.putIfAbsent(typeref, value);
- }
- }
-
- @Override
- public void onGlobalContextUpdated(SchemaContext context) {
- currentSchema = context;
- }
-
- @SuppressWarnings({ "unchecked", "rawtypes" })
- @Override
- public void onChoiceCodecCreated(Class<?> choiceClass,
- Class<? extends BindingCodec<Map<QName, Object>, Object>> choiceCodec, ChoiceNode schema) {
- ChoiceCodec<?> oldCodec = choiceCodecs.get(choiceClass);
- checkState(oldCodec == null);
- BindingCodec<Map<QName, Object>, Object> delegate = newInstanceOf(choiceCodec);
- ChoiceCodecImpl<?> newCodec = new ChoiceCodecImpl(delegate);
- choiceCodecs.put(choiceClass, newCodec);
- CodecMapping.setClassToCaseMap(choiceCodec, (Map<Class<?>, BindingCodec<?, ?>>) classToCaseRawCodec);
- CodecMapping.setCompositeNodeToCaseMap(choiceCodec, newCodec.getCompositeToCase());
-
- tryToCreateCasesCodecs(schema);
-
- }
-
- private void tryToCreateCasesCodecs(ChoiceNode schema) {
- for (ChoiceCaseNode caseNode : schema.getCases()) {
- SchemaPath path = caseNode.getPath();
- GeneratedTypeBuilder type;
- if (path != null && (type = pathToType.get(path)) != null) {
- ReferencedTypeImpl typeref = new ReferencedTypeImpl(type.getPackageName(), type.getName());
- ChoiceCaseCodecImpl partialCodec = typeToCaseCodecs.get(typeref);
- if (partialCodec.getSchema() == null) {
- partialCodec.setSchema(caseNode);
- }
-
- Class<?> caseClass = ClassLoaderUtils.tryToLoadClassWithTCCL(type.getFullyQualifiedName());
- if (caseClass != null) {
- getCaseCodecFor(caseClass);
- }
- }
- }
-
- }
-
- @Override
- public void onValueCodecCreated(Class<?> valueClass, Class<?> valueCodec) {
- }
-
- @Override
- public void onCaseCodecCreated(Class<?> choiceClass,
- Class<? extends BindingCodec<Map<QName, Object>, Object>> choiceCodec) {
- }
-
- @Override
- public void onDataContainerCodecCreated(Class<?> dataClass, Class<? extends BindingCodec<?, ?>> dataCodec) {
- if (Augmentable.class.isAssignableFrom(dataClass)) {
- AugmentableCompositeCodec augmentableCodec = getAugmentableCodec(dataClass);
- CodecMapping.setAugmentationCodec(dataCodec, augmentableCodec);
- }
-
- }
-
- public AugmentableCompositeCodec getAugmentableCodec(Class<?> dataClass) {
- AugmentableCompositeCodec ret = augmentableCodecs.get(dataClass);
- if (ret != null) {
- return ret;
- }
- ret = new AugmentableCompositeCodec(dataClass);
- augmentableCodecs.put(dataClass, ret);
- return ret;
- }
-
- private static abstract class IntermediateCodec<T> implements //
- DomCodec<T>, Delegator<BindingCodec<Map<QName, Object>, Object>> {
-
- private final BindingCodec<Map<QName, Object>, Object> delegate;
-
- @Override
- public BindingCodec<Map<QName, Object>, Object> getDelegate() {
- return delegate;
- }
-
- public IntermediateCodec(BindingCodec<Map<QName, Object>, Object> delegate) {
- this.delegate = delegate;
- }
-
- @Override
- public Node<?> serialize(ValueWithQName<T> input) {
- Map<QName, Object> intermediateOutput = delegate.serialize(input);
- return toNode(intermediateOutput);
- }
- }
-
- private static class IdentifierCodecImpl<T extends Identifier<?>> //
- extends IntermediateCodec<T> //
- implements IdentifierCodec<T> {
-
- public IdentifierCodecImpl(BindingCodec<Map<QName, Object>, Object> delegate) {
- super(delegate);
- }
-
- @Override
- public ValueWithQName<T> deserialize(Node<?> input) {
- QName qname = input.getNodeType();
- @SuppressWarnings("unchecked")
- T value = (T) getDelegate().deserialize((Map<QName, Object>) input);
- return new ValueWithQName<T>(qname, value);
- }
-
- @Override
- public CompositeNode serialize(ValueWithQName<T> input) {
- return (CompositeNode) super.serialize(input);
- }
- }
-
- private static class DataContainerCodecImpl<T extends DataContainer> //
- extends IntermediateCodec<T> //
- implements DataContainerCodec<T> {
-
- public DataContainerCodecImpl(BindingCodec<Map<QName, Object>, Object> delegate) {
- super(delegate);
- }
-
- @Override
- public ValueWithQName<T> deserialize(Node<?> input) {
- if (input == null) {
- return null;
- }
- QName qname = input.getNodeType();
- @SuppressWarnings("unchecked")
- T value = (T) getDelegate().deserialize((Map<QName, Object>) input);
- return new ValueWithQName<T>(qname, value);
- }
-
- @Override
- public CompositeNode serialize(ValueWithQName<T> input) {
- return (CompositeNode) super.serialize(input);
- }
- }
-
- @SuppressWarnings("rawtypes")
- private static class ChoiceCaseCodecImpl<T extends DataContainer> implements ChoiceCaseCodec<T>, //
- Delegator<BindingCodec> {
- private boolean augmenting;
- private BindingCodec delegate;
-
- private Set<String> validNames;
- private Set<QName> validQNames;
- private ChoiceCaseNode schema;
-
- public void setSchema(ChoiceCaseNode caseNode) {
- this.schema = schema;
- this.schema = caseNode;
- validNames = new HashSet<>();
- validQNames = new HashSet<>();
- for (DataSchemaNode node : caseNode.getChildNodes()) {
- QName qname = node.getQName();
- validQNames.add(qname);
- validNames.add(qname.getLocalName());
- }
- augmenting = caseNode.isAugmenting();
- }
-
- public ChoiceCaseCodecImpl() {
- this.delegate = NOT_READY_CODEC;
- }
-
- public ChoiceCaseCodecImpl(ChoiceCaseNode caseNode) {
- this.delegate = NOT_READY_CODEC;
- setSchema(caseNode);
- }
-
- @Override
- public ValueWithQName<T> deserialize(Node<?> input) {
- throw new UnsupportedOperationException("Direct invocation of this codec is not allowed.");
- }
-
- @Override
- public CompositeNode serialize(ValueWithQName<T> input) {
- throw new UnsupportedOperationException("Direct invocation of this codec is not allowed.");
- }
-
- public BindingCodec getDelegate() {
- return delegate;
- }
-
- public void setDelegate(BindingCodec delegate) {
- this.delegate = delegate;
- }
-
- public ChoiceCaseNode getSchema() {
- return schema;
- }
-
- @Override
- public boolean isAcceptable(Node<?> input) {
- if (input instanceof CompositeNode) {
- if (augmenting) {
- return checkAugmenting((CompositeNode) input);
- } else {
- return checkLocal((CompositeNode) input);
- }
- }
- return false;
- }
-
- private boolean checkLocal(CompositeNode input) {
- QName parent = input.getNodeType();
- for (Node<?> childNode : input.getChildren()) {
- QName child = childNode.getNodeType();
- if (!Objects.equals(parent.getNamespace(), child.getNamespace())
- || !Objects.equals(parent.getRevision(), child.getRevision())) {
- continue;
- }
- if (validNames.contains(child.getLocalName())) {
- return true;
- }
- }
- return false;
- }
-
- private boolean checkAugmenting(CompositeNode input) {
- for (Node<?> child : input.getChildren()) {
- if (validQNames.contains(child.getNodeType())) {
- return true;
- }
- }
- return false;
- }
- }
-
- private static class ChoiceCodecImpl<T> implements ChoiceCodec<T> {
-
- private final BindingCodec<Map<QName, Object>, Object> delegate;
-
- @SuppressWarnings("rawtypes")
- private final Map<Class, ChoiceCaseCodecImpl<?>> cases = new WeakHashMap<>();
-
- private final CaseCompositeNodeMapFacade CompositeToCase;
-
- public ChoiceCodecImpl(BindingCodec<Map<QName, Object>, Object> delegate) {
- this.delegate = delegate;
- this.CompositeToCase = new CaseCompositeNodeMapFacade(cases);
- }
-
- @Override
- public ValueWithQName<T> deserialize(Node<?> input) {
- throw new UnsupportedOperationException("Direct invocation of this codec is not allowed.");
- }
-
- @Override
- public Node<?> serialize(ValueWithQName<T> input) {
- throw new UnsupportedOperationException("Direct invocation of this codec is not allowed.");
- }
-
- public CaseCompositeNodeMapFacade getCompositeToCase() {
- return CompositeToCase;
- }
-
- public Map<Class, ChoiceCaseCodecImpl<?>> getCases() {
- return cases;
- }
-
- public BindingCodec<Map<QName, Object>, Object> getDelegate() {
- return delegate;
- }
-
- }
-
- @SuppressWarnings("rawtypes")
- private class CaseClassMapFacade extends MapFacadeBase {
-
- @Override
- public Set<java.util.Map.Entry<Class, BindingCodec<Object, Object>>> entrySet() {
- return Collections.emptySet();
- }
-
- @Override
- public BindingCodec get(Object key) {
- if (key instanceof Class) {
- Class cls = (Class) key;
- // bindingClassEncountered(cls);
- ChoiceCaseCodecImpl caseCodec = getCaseCodecFor(cls);
- return caseCodec.getDelegate();
- }
- return null;
- }
- }
-
- @SuppressWarnings("rawtypes")
- private static class CaseCompositeNodeMapFacade extends MapFacadeBase<CompositeNode> {
-
- final Map<Class, ChoiceCaseCodecImpl<?>> choiceCases;
-
- public CaseCompositeNodeMapFacade(Map<Class, ChoiceCaseCodecImpl<?>> choiceCases) {
- this.choiceCases = choiceCases;
- }
-
- @Override
- public BindingCodec get(Object key) {
- if (!(key instanceof CompositeNode)) {
- return null;
- }
- for (java.util.Map.Entry<Class, ChoiceCaseCodecImpl<?>> entry : choiceCases.entrySet()) {
- ChoiceCaseCodecImpl<?> codec = entry.getValue();
- if (codec.isAcceptable((CompositeNode) key)) {
- return codec.getDelegate();
- }
- }
- return null;
- }
-
- }
-
- /**
- * This map is used as only facade for {@link BindingCodec} in different
- * classloaders to retrieve codec dynamicly based on provided key.
- *
- * @param <T>
- * Key type
- */
- @SuppressWarnings("rawtypes")
- private static abstract class MapFacadeBase<T> implements Map<T, BindingCodec<?, ?>> {
-
- @Override
- public boolean containsKey(Object key) {
- return get(key) != null;
- }
-
- @Override
- public void clear() {
- throw notModifiable();
- }
-
- @Override
- public boolean equals(Object obj) {
- return super.equals(obj);
- }
-
- @Override
- public BindingCodec remove(Object key) {
- return null;
- }
-
- @Override
- public int size() {
- return 0;
- }
-
- @Override
- public Collection<BindingCodec<?, ?>> values() {
- return Collections.emptySet();
- }
-
- private UnsupportedOperationException notModifiable() {
- return new UnsupportedOperationException("Not externally modifiable.");
- }
-
- @Override
- public BindingCodec<Map<QName, Object>, Object> put(T key, BindingCodec<?, ?> value) {
- throw notModifiable();
- }
-
- @Override
- public void putAll(Map<? extends T, ? extends BindingCodec<?, ?>> m) {
- throw notModifiable();
- }
-
- @Override
- public int hashCode() {
- return super.hashCode();
- }
-
- @Override
- public boolean isEmpty() {
- return true;
- }
-
- @Override
- public Set<T> keySet() {
- return Collections.emptySet();
- }
-
- @Override
- public Set<java.util.Map.Entry<T, BindingCodec<?, ?>>> entrySet() {
- return Collections.emptySet();
- }
-
- @Override
- public boolean containsValue(Object value) {
- return false;
- }
- }
-
- @SuppressWarnings({ "rawtypes", "unchecked" })
- private class AugmentableCompositeCodec implements BindingCodec {
-
- private final Class augmentableType;
-
- Map<Class, AugmentationCodec<?>> localAugmentationCodecs = new WeakHashMap<>();
-
- public AugmentableCompositeCodec(Class type) {
- checkArgument(Augmentable.class.isAssignableFrom(type));
- augmentableType = type;
- }
-
- @Override
- public Object serialize(Object input) {
- if (input instanceof Augmentable<?>) {
-
- Map<Class, Augmentation> augmentations = getAugmentations(input);
- return serializeImpl(augmentations);
- }
- return null;
- }
-
- private Map<Class, Augmentation> getAugmentations(Object input) {
- Field augmentationField;
- try {
- augmentationField = input.getClass().getDeclaredField("augmentation");
- augmentationField.setAccessible(true);
- Map<Class, Augmentation> augMap = (Map<Class, Augmentation>) augmentationField.get(input);
- return augMap;
- } catch (IllegalArgumentException | IllegalAccessException | NoSuchFieldException | SecurityException e) {
- LOG.debug("Could not read augmentations for {}", input, e);
- }
- return Collections.emptyMap();
- }
-
- private List serializeImpl(Map<Class, Augmentation> input) {
- List ret = new ArrayList<>();
- for (Entry<Class, Augmentation> entry : input.entrySet()) {
- AugmentationCodec codec = getCodecForAugmentation(entry.getKey());
- CompositeNode node = codec.serialize(new ValueWithQName(null, entry.getValue()));
- ret.addAll(node.getChildren());
- }
- return ret;
- }
-
- public synchronized <T extends Augmentation<?>> void addAugmentationCodec(Class<T> augmentationClass,
- AugmentationCodec<T> value) {
- localAugmentationCodecs.put(augmentationClass, value);
- }
-
- @Override
- public Map<Class, Augmentation> deserialize(Object input) {
- Map<Class, Augmentation> ret = new HashMap<>();
- if (input instanceof CompositeNode) {
- List<Entry<Class, AugmentationCodec<?>>> codecs = new ArrayList<>(localAugmentationCodecs.entrySet());
- for (Entry<Class, AugmentationCodec<?>> codec : codecs) {
- ValueWithQName<?> value = codec.getValue().deserialize((CompositeNode) input);
- if (value != null && value.getValue() != null) {
- ret.put(codec.getKey(), (Augmentation) value.getValue());
- }
- }
- }
- return ret;
- }
-
- public Class getAugmentableType() {
- return augmentableType;
- }
- }
-
- @SuppressWarnings({ "rawtypes", "unchecked" })
- private static class LateMixinCodec implements BindingCodec, Delegator<BindingCodec> {
-
- private BindingCodec delegate;
-
- @Override
- public BindingCodec getDelegate() {
- if (delegate == null) {
- throw new IllegalStateException("Codec not initialized yet.");
- }
- return delegate;
- }
-
- @Override
- public Object deserialize(Object input) {
- return getDelegate().deserialize(input);
- }
-
- @Override
- public Object serialize(Object input) {
- return getDelegate().serialize(input);
- }
- }
-
- private static class AugmentationCodecWrapper<T extends Augmentation<?>> implements AugmentationCodec<T>,
- Delegator<BindingCodec> {
-
- private BindingCodec delegate;
- private QName augmentationQName;
-
- public AugmentationCodecWrapper(BindingCodec<Map<QName, Object>, Object> rawCodec) {
- this.delegate = rawCodec;
- this.augmentationQName = BindingReflections.findQName(rawCodec.getClass());
- }
-
- @Override
- public BindingCodec getDelegate() {
- return delegate;
- }
-
- @Override
- public CompositeNode serialize(ValueWithQName<T> input) {
- @SuppressWarnings("unchecked")
- List<Map<QName, Object>> rawValues = (List<Map<QName, Object>>) getDelegate().serialize(input);
- List<Node<?>> serialized = new ArrayList<>(rawValues.size());
- for (Map<QName, Object> val : rawValues) {
- serialized.add(toNode(val));
- }
- return new CompositeNodeTOImpl(input.getQname(), null, serialized);
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public ValueWithQName<T> deserialize(Node<?> input) {
- Object rawCodecValue = getDelegate().deserialize((Map<QName, Object>) input);
- return new ValueWithQName<T>(input.getNodeType(), (T) rawCodecValue);
- }
-
- @Override
- public QName getAugmentationQName() {
- return augmentationQName;
- }
- }
-
- private class IdentityCompositeCodec implements IdentitityCodec {
-
- @Override
- public Object deserialize(Object input) {
- checkArgument(input instanceof QName);
- return deserialize((QName) input);
- }
-
- @Override
- public Class<?> deserialize(QName input) {
- Type type = qnamesToIdentityMap.get(input);
- if (type == null) {
- return null;
- }
- ReferencedTypeImpl typeref = new ReferencedTypeImpl(type.getPackageName(), type.getName());
- WeakReference<Class> softref = typeToClass.get(typeref);
- if (softref == null) {
- return null;
- }
- return softref.get();
- }
-
- @Override
- public QName serialize(Class input) {
- checkArgument(BaseIdentity.class.isAssignableFrom(input));
- bindingClassEncountered(input);
- QName qname = identityQNames.get(input);
- if (qname != null) {
- return qname;
- }
- ConcreteType typeref = Types.typeForClass(input);
- qname = typeToQname.get(typeref);
- if (qname != null) {
- identityQNames.put(input, qname);
- }
- return qname;
- }
-
- @Override
- public Object serialize(Object input) {
- checkArgument(input instanceof Class);
- return serialize((Class) input);
- }
- }
-
- public boolean isCodecAvailable(Class<? extends DataContainer> cls) {
- if (containerCodecs.containsKey(cls)) {
- return true;
- }
- if (identifierCodecs.containsKey(cls)) {
- return true;
- }
- if (choiceCodecs.containsKey(cls)) {
- return true;
- }
- if (caseCodecs.containsKey(cls)) {
- return true;
- }
- if (augmentableCodecs.containsKey(cls)) {
- return true;
- }
- if (augmentationCodecs.containsKey(cls)) {
- return true;
- }
- return false;
- }
-}
\ No newline at end of file
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.impl
-
-import org.opendaylight.controller.sal.binding.dom.serializer.impl.TransformerGenerator
-import javassist.ClassPool
-import org.opendaylight.yangtools.yang.model.api.SchemaContext
-import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener
-import org.opendaylight.yangtools.sal.binding.generator.impl.BindingGeneratorImpl
-import java.util.Map
-import org.opendaylight.yangtools.sal.binding.model.api.Type
-import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder
-import org.opendaylight.yangtools.yang.model.api.SchemaNode
-import java.util.concurrent.ConcurrentHashMap
-import org.opendaylight.yangtools.yang.data.api.CompositeNode
-import org.opendaylight.yangtools.yang.binding.DataObject
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
-import java.util.Map.Entry
-import java.util.AbstractMap.SimpleEntry
-import org.opendaylight.yangtools.yang.model.api.SchemaPath
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil
-import org.opendaylight.yangtools.yang.binding.DataContainer
-import java.util.concurrent.ConcurrentMap
-import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType
-import com.google.common.collect.HashMultimap
-import com.google.common.util.concurrent.SettableFuture
-import java.util.concurrent.Future
-import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl
-import org.opendaylight.controller.sal.binding.dom.serializer.impl.LazyGeneratedCodecRegistry
-import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentMappingService
-import org.slf4j.LoggerFactory
-import org.opendaylight.controller.sal.binding.dom.serializer.api.ValueWithQName
-import org.opendaylight.controller.sal.binding.dom.serializer.api.DataContainerCodec
-import org.opendaylight.yangtools.binding.generator.util.Types
-import org.osgi.framework.BundleContext
-import java.util.Hashtable
-import org.osgi.framework.ServiceRegistration
-import org.opendaylight.controller.sal.binding.impl.connect.dom.DeserializationException
-import java.util.concurrent.Callable
-import org.opendaylight.yangtools.yang.binding.Augmentation
-import org.opendaylight.controller.sal.binding.impl.util.YangSchemaUtils
-import org.opendaylight.controller.sal.binding.dom.serializer.api.AugmentationCodec
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates
-import java.util.ArrayList
-import org.opendaylight.yangtools.yang.data.api.Node
-import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
-import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
-import org.opendaylight.yangtools.yang.binding.RpcService
-import java.util.Set
-import org.opendaylight.yangtools.yang.common.QName
-import com.google.common.collect.FluentIterable
-import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil
-
-class RuntimeGeneratedMappingServiceImpl implements BindingIndependentMappingService, SchemaServiceListener, AutoCloseable {
-
- @Property
- ClassPool pool;
-
- private static val LOG = LoggerFactory.getLogger(RuntimeGeneratedMappingServiceImpl);
-
- @Property
- extension TransformerGenerator binding;
-
- @Property
- extension LazyGeneratedCodecRegistry registry;
-
- @Property
- val ConcurrentMap<Type, Type> typeDefinitions = new ConcurrentHashMap();
-
- @Property
- val ConcurrentMap<Type, GeneratedTypeBuilder> typeToDefinition = new ConcurrentHashMap();
-
- @Property
- val ConcurrentMap<Type, SchemaNode> typeToSchemaNode = new ConcurrentHashMap();
-
- @Property
- val ConcurrentMap<Type,Set<QName>> serviceTypeToRpc = new ConcurrentHashMap();
-
- val promisedTypeDefinitions = HashMultimap.<Type, SettableFuture<GeneratedTypeBuilder>>create;
-
- val promisedSchemas = HashMultimap.<Type, SettableFuture<SchemaNode>>create;
-
- ServiceRegistration<SchemaServiceListener> listenerRegistration
-
- override onGlobalContextUpdated(SchemaContext arg0) {
- recreateBindingContext(arg0);
- registry.onGlobalContextUpdated(arg0);
- }
-
- def recreateBindingContext(SchemaContext schemaContext) {
- val newBinding = new BindingGeneratorImpl();
- newBinding.generateTypes(schemaContext);
-
- for (entry : newBinding.moduleContexts.entrySet) {
-
- registry.onModuleContextAdded(schemaContext, entry.key, entry.value);
- binding.pathToType.putAll(entry.value.childNodes)
- val module = entry.key;
- val context = entry.value;
- updateBindingFor(context.childNodes, schemaContext);
- updateBindingFor(context.cases, schemaContext);
- val namespace = BindingGeneratorUtil.moduleNamespaceToPackageName(module);
-
- if(!module.rpcs.empty) {
- val rpcs = FluentIterable.from(module.rpcs).transform[QName].toSet
- val serviceClass = new ReferencedTypeImpl(namespace,BindingGeneratorUtil.parseToClassName(module.name)+"Service");
- serviceTypeToRpc.put(serviceClass,rpcs);
- }
-
- val typedefs = context.typedefs;
- for (typedef : typedefs.entrySet) {
- val typeRef = new ReferencedTypeImpl(typedef.value.packageName,typedef.value.name)
- binding.typeDefinitions.put(typeRef, typedef.value as GeneratedType);
- val schemaNode = YangSchemaUtils.findTypeDefinition(schemaContext,typedef.key);
- if(schemaNode != null) {
-
- binding.typeToSchemaNode.put(typeRef,schemaNode);
- } else {
- LOG.error("Type definition for {} is not available",typedef.value);
- }
-
- }
- val augmentations = context.augmentations;
- for (augmentation : augmentations) {
- binding.typeToDefinition.put(augmentation, augmentation);
- }
-
- binding.typeToAugmentation.putAll(context.typeToAugmentation);
- }
- }
-
- override CompositeNode toDataDom(DataObject data) {
- toCompositeNodeImpl(data);
- }
-
- override Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> toDataDom(
- Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry) {
-
- try {
- val key = toDataDom(entry.key)
- var CompositeNode data;
- if(Augmentation.isAssignableFrom(entry.key.targetType)) {
- data = toCompositeNodeImpl(key,entry.value);
- } else {
- data = toCompositeNodeImpl(entry.value);
- }
- return new SimpleEntry(key, data);
-
- } catch (Exception e) {
- LOG.error("Error during serialization for {}.", entry.key,e);
- throw e;
- }
- }
-
- private def CompositeNode toCompositeNodeImpl(DataObject object) {
- val cls = object.implementedInterface;
- waitForSchema(cls);
- val codec = registry.getCodecForDataObject(cls) as DataContainerCodec<DataObject>;
- val ret = codec.serialize(new ValueWithQName(null, object));
- return ret as CompositeNode;
- }
-
-
- private def CompositeNode toCompositeNodeImpl(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier identifier,DataObject object) {
-
- //val cls = object.implementedInterface;
- //waitForSchema(cls);
- val last = identifier.path.last;
- val codec = registry.getCodecForAugmentation(object.implementedInterface as Class) as AugmentationCodec;
- val ret = codec.serialize(new ValueWithQName(last.nodeType, object));
- if(last instanceof NodeIdentifierWithPredicates) {
- val predicates = last as NodeIdentifierWithPredicates;
- val newNodes = new ArrayList<Node<?>>(predicates.keyValues.size);
- for(predicate : predicates.keyValues.entrySet) {
- newNodes.add(new SimpleNodeTOImpl(predicate.key,null,predicate.value));
- }
- newNodes.addAll(ret.children);
- return new CompositeNodeTOImpl(last.nodeType,null,newNodes);
- }
- return ret as CompositeNode;
- }
-
- private def void waitForSchema(Class<? extends DataContainer> class1) {
- if(Augmentation.isAssignableFrom(class1)) {
- /* FIXME: We should wait also for augmentations. Currently YANGTools does not provide correct
- * mapping between java Augmentation classes and augmentations.
- */
- return;
- }
- if(registry.isCodecAvailable(class1)) {
- return;
- }
- val ref = Types.typeForClass(class1);
- getSchemaWithRetry(ref);
- }
-
- override org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toDataDom(
- InstanceIdentifier<? extends DataObject> path) {
- for (arg : path.path) {
- waitForSchema(arg.type);
- }
- return registry.instanceIdentifierCodec.serialize(path);
- }
-
- override dataObjectFromDataDom(InstanceIdentifier<? extends DataObject> path, CompositeNode node) {
- dataObjectFromDataDom(path.targetType,node) as DataObject;
- }
-
- override fromDataDom(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier entry) {
- return tryDeserialization[ |
- registry.instanceIdentifierCodec.deserialize(entry);
- ]
- }
-
- private static def <T> T tryDeserialization(Callable<T> deserializationBlock) throws DeserializationException {
- try {
- deserializationBlock.call()
- } catch (Exception e) {
-
- // FIXME: Make this block providing more information.
- throw new DeserializationException(e);
- }
- }
-
- private def void updateBindingFor(Map<SchemaPath, GeneratedTypeBuilder> map, SchemaContext module) {
-
- for (entry : map.entrySet) {
- val schemaNode = SchemaContextUtil.findDataSchemaNode(module, entry.key);
-
- //LOG.info("{} : {}",entry.key,entry.value.fullyQualifiedName)
- val typeRef = new ReferencedTypeImpl(entry.value.packageName,entry.value.name)
- typeToDefinition.put(typeRef, entry.value);
- if (schemaNode != null) {
- typeToSchemaNode.put(typeRef, schemaNode);
- updatePromisedSchemas(typeRef, schemaNode);
- }
-
- }
- }
-
- public def void start(BundleContext ctx) {
- binding = new TransformerGenerator(pool);
- registry = new LazyGeneratedCodecRegistry()
- registry.generator = binding
-
- //binding.staticFieldsInitializer = registry
- binding.listener = registry
- binding.typeToDefinition = typeToDefinition
- binding.typeToSchemaNode = typeToSchemaNode
- binding.typeDefinitions = typeDefinitions
- if (ctx !== null) {
- listenerRegistration = ctx.registerService(SchemaServiceListener, this, new Hashtable<String, String>());
- }
- }
-
- override getRpcQNamesFor(Class<? extends RpcService> service) {
- return serviceTypeToRpc.get(new ReferencedTypeImpl(service.package.name,service.simpleName));
- }
-
- private def getSchemaWithRetry(Type type) {
- val typeDef = typeToSchemaNode.get(type);
- if (typeDef !== null) {
- return typeDef;
- }
- LOG.trace("Thread blocked waiting for schema for: {}",type.fullyQualifiedName)
- return type.getSchemaInFuture.get();
- }
-
- private def Future<SchemaNode> getSchemaInFuture(Type type) {
- val future = SettableFuture.<SchemaNode>create()
- promisedSchemas.put(type, future);
- return future;
- }
-
- private def void updatePromisedSchemas(Type builder, SchemaNode schema) {
- val ref = new ReferencedTypeImpl(builder.packageName, builder.name);
- val futures = promisedSchemas.get(ref);
- if (futures === null || futures.empty) {
- return;
- }
- for (future : futures) {
- future.set(schema);
- }
- promisedSchemas.removeAll(builder);
- }
-
- override close() throws Exception {
- listenerRegistration?.unregister();
- }
-
- override dataObjectFromDataDom(Class<? extends DataContainer> container, CompositeNode domData) {
- return tryDeserialization[ |
- if (domData == null) {
- return null;
- }
- val transformer = registry.getCodecForDataObject(container);
- val ret = transformer.deserialize(domData)?.value as DataObject;
- return ret;
- ]
- }
-
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.impl;
-
-public interface StaticFieldInitializer {
-
- void initializeStaticFields(Class<?> cls);
-}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.dom.serializer.impl
-
-import javassist.ClassPool
-import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType
-import org.opendaylight.yangtools.yang.model.api.SchemaNode
-import org.opendaylight.controller.sal.binding.codegen.util.JavassistUtils
-import javassist.CtClass
-import java.util.Map
-import org.opendaylight.yangtools.yang.common.QName
-import javassist.CtField
-import static javassist.Modifier.*
-import static org.opendaylight.controller.sal.binding.dom.serializer.impl.CodecMapping.*
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer
-import org.opendaylight.yangtools.sal.binding.model.api.Type
-import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder
-import org.opendaylight.yangtools.binding.generator.util.Types
-import org.opendaylight.yangtools.sal.binding.model.api.ParameterizedType
-import java.util.HashMap
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode
-import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode
-import java.util.List
-import java.util.TreeSet
-import com.google.common.base.Joiner
-import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject
-import org.opendaylight.yangtools.sal.binding.model.api.Enumeration
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode
-import static org.opendaylight.controller.sal.binding.impl.util.ClassLoaderUtils.*;
-import org.opendaylight.yangtools.yang.binding.BindingDeserializer
-import org.opendaylight.yangtools.yang.binding.BindingCodec
-import org.slf4j.LoggerFactory
-import org.opendaylight.controller.sal.binding.codegen.CodeGenerationException
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode
-import java.security.ProtectionDomain
-import java.io.File
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
-import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty
-import java.util.Map.Entry
-import java.util.AbstractMap.SimpleEntry
-import org.opendaylight.yangtools.yang.binding.DataObject
-import org.opendaylight.yangtools.yang.binding.Augmentation
-import java.util.Iterator
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema
-import java.util.concurrent.ConcurrentHashMap
-import static extension org.opendaylight.controller.sal.binding.impl.util.YangSchemaUtils.*;
-import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl
-import org.opendaylight.yangtools.yang.model.util.ExtendedType
-import org.opendaylight.yangtools.yang.model.util.EnumerationType
-import static com.google.common.base.Preconditions.*
-import org.opendaylight.yangtools.yang.model.api.SchemaPath
-import javassist.CtMethod
-import javassist.CannotCompileException
-import java.util.concurrent.locks.Lock
-import java.util.concurrent.Callable
-import org.opendaylight.controller.sal.binding.impl.util.ClassLoaderUtils
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition
-import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition
-import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition
-import java.util.HashSet
-import java.util.Collections
-import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit
-import java.util.Set
-import org.opendaylight.controller.sal.binding.codegen.impl.XtendHelper
-
-class TransformerGenerator {
-
- private static val log = LoggerFactory.getLogger(TransformerGenerator)
-
- public static val STRING = Types.typeForClass(String);
- public static val BOOLEAN = Types.typeForClass(Boolean);
- public static val INTEGER = Types.typeForClass(Integer);
- public static val INSTANCE_IDENTIFIER = Types.typeForClass(InstanceIdentifier)
-
- //public static val DECIMAL = Types.typeForClass(Decimal);
- public static val LONG = Types.typeForClass(Long);
-
- val ClassPool classPool
- val extension JavassistUtils utils;
-
- CtClass BINDING_CODEC
-
- CtClass ctQName
-
- @Property
- var File classFileCapturePath;
-
- @Property
- var Map<Type, Type> typeDefinitions = new ConcurrentHashMap();
-
- @Property
- var Map<Type, GeneratedTypeBuilder> typeToDefinition = new ConcurrentHashMap();
-
- @Property
- var Map<SchemaPath, GeneratedTypeBuilder> pathToType = new ConcurrentHashMap();
-
- @Property
- var Map<Type, SchemaNode> typeToSchemaNode = new ConcurrentHashMap();
-
- @Property
- var Map<Type, AugmentationSchema> typeToAugmentation = new ConcurrentHashMap();
-
- @Property
- var GeneratorListener listener;
-
- public static val CLASS_TYPE = Types.typeForClass(Class);
-
- public new(ClassPool pool) {
- classPool = pool;
- utils = new JavassistUtils(pool)
-
- BINDING_CODEC = BindingCodec.asCtClass;
- ctQName = QName.asCtClass
- }
-
- def Class<? extends BindingCodec<Map<QName, Object>, Object>> transformerFor(Class<?> inputType) {
- return withClassLoaderAndLock(inputType.classLoader, lock) [ |
- val ret = getGeneratedClass(inputType)
- if (ret !== null) {
- listener.onClassProcessed(inputType);
- return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- }
- val ref = Types.typeForClass(inputType)
- val node = typeToSchemaNode.get(ref)
- val typeSpecBuilder = typeToDefinition.get(ref)
- checkState(typeSpecBuilder !== null, "Could not find typedefinition for %s", inputType.name);
- val typeSpec = typeSpecBuilder.toInstance();
- val newret = generateTransformerFor(inputType, typeSpec, node);
- listener.onClassProcessed(inputType);
- return newret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- ]
- }
-
- def Class<? extends BindingCodec<Map<QName, Object>, Object>> transformerFor(Class<?> inputType, DataSchemaNode node) {
- return withClassLoaderAndLock(inputType.classLoader, lock) [ |
- val ret = getGeneratedClass(inputType)
- if (ret !== null) {
- listener.onClassProcessed(inputType);
- return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- }
- val ref = Types.typeForClass(inputType)
- var typeSpecBuilder = typeToDefinition.get(ref)
- if (typeSpecBuilder == null) {
- typeSpecBuilder = pathToType.get(node.path);
- }
- var schemaNode = typeToSchemaNode.get(ref);
- if(schemaNode === null) {
- schemaNode = node;
- }
- checkState(typeSpecBuilder !== null, "Could not find TypeDefinition for %s, $s", inputType.name, node);
- val typeSpec = typeSpecBuilder.toInstance();
- val newret = generateTransformerFor(inputType, typeSpec, schemaNode);
- listener.onClassProcessed(inputType);
- return newret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- ]
- }
-
- def Class<? extends BindingCodec<Map<QName, Object>, Object>> augmentationTransformerFor(Class<?> inputType) {
- return withClassLoaderAndLock(inputType.classLoader, lock) [ |
- val ret = getGeneratedClass(inputType)
- if (ret !== null) {
- return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- }
- val ref = Types.typeForClass(inputType)
- val node = typeToAugmentation.get(ref)
- val typeSpecBuilder = typeToDefinition.get(ref)
- val typeSpec = typeSpecBuilder.toInstance();
- val newret = generateAugmentationTransformerFor(inputType, typeSpec, node);
- listener.onClassProcessed(inputType);
- return newret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- ]
- }
-
- def Class<? extends BindingCodec<Object, Object>> caseCodecFor(Class<?> inputType, ChoiceCaseNode node) {
- return withClassLoaderAndLock(inputType.classLoader, lock) [ |
- val ret = getGeneratedClass(inputType)
- if (ret !== null) {
- return ret as Class<? extends BindingCodec<Object, Object>>;
- }
- val ref = Types.typeForClass(inputType)
- val typeSpecBuilder = typeToDefinition.get(ref)
- val typeSpec = typeSpecBuilder.toInstance();
- val newret = generateCaseCodec(inputType, typeSpec, node);
- return newret as Class<? extends BindingCodec<Object, Object>>;
- ]
- }
-
- def Class<? extends BindingCodec<Map<QName, Object>, Object>> keyTransformerForIdentifiable(Class<?> parentType) {
- return withClassLoaderAndLock(parentType.classLoader, lock) [ |
- val inputName = parentType.name + "Key";
- val inputType = loadClassWithTCCL(inputName);
- val ret = getGeneratedClass(inputType)
- if (ret !== null) {
- return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- }
- val ref = Types.typeForClass(parentType)
- val node = typeToSchemaNode.get(ref) as ListSchemaNode
- val typeSpecBuilder = typeToDefinition.get(ref)
- val typeSpec = typeSpecBuilder.identifierDefinition;
- val newret = generateKeyTransformerFor(inputType, typeSpec, node);
- return newret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- ]
- }
-
- def getIdentifierDefinition(GeneratedTypeBuilder builder) {
- val inst = builder.toInstance
- val keyMethod = inst.methodDefinitions.findFirst[name == "getKey"]
- return keyMethod.returnType as GeneratedTransferObject
- }
-
- def Class<? extends BindingCodec<Map<QName, Object>, Object>> keyTransformerForIdentifier(Class<?> inputType) {
- return withClassLoaderAndLock(inputType.classLoader, lock) [ |
- val ret = getGeneratedClass(inputType)
- if (ret !== null) {
- return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- }
- val ref = Types.typeForClass(inputType)
- val node = typeToSchemaNode.get(ref) as ListSchemaNode
- val typeSpecBuilder = typeToDefinition.get(ref)
- val typeSpec = typeSpecBuilder.toInstance();
- val newret = generateKeyTransformerFor(inputType, typeSpec, node);
- return newret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- ]
- }
-
- private def Class<?> keyTransformerFor(Class<?> inputType, GeneratedType type, ListSchemaNode schema) {
- return withClassLoaderAndLock(inputType.classLoader, lock) [ |
- val transformer = getGeneratedClass(inputType)
- if (transformer != null) {
- return transformer;
- }
- val newret = generateKeyTransformerFor(inputType, type, schema);
- return newret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- ]
- }
-
- private def Class<?> getGeneratedClass(Class<? extends Object> cls) {
-
- try {
- return loadClassWithTCCL(cls.codecClassName)
- } catch (ClassNotFoundException e) {
- return null;
- }
- }
-
- private def Class<?> keyTransformer(GeneratedType type, ListSchemaNode node) {
- val cls = loadClassWithTCCL(type.resolvedName + "Key");
- keyTransformerFor(cls, type, node);
- }
-
- private def serializer(Type type, DataSchemaNode node) {
- val cls = loadClassWithTCCL(type.resolvedName);
- transformerFor(cls, node);
- }
-
- private def Class<?> valueSerializer(GeneratedTransferObject type, TypeDefinition<?> typeDefinition) {
- val cls = loadClassWithTCCL(type.resolvedName);
- val transformer = cls.generatedClass;
- if (transformer !== null) {
- return transformer;
- }
- var baseType = typeDefinition;
- while (baseType.baseType != null) {
- baseType = baseType.baseType;
- }
- val finalType = baseType;
- return withClassLoaderAndLock(cls.classLoader, lock) [ |
- val valueTransformer = generateValueTransformer(cls, type, finalType);
- return valueTransformer;
- ]
- }
-
- private def Class<?> valueSerializer(Enumeration type, TypeDefinition<?> typeDefinition) {
- val cls = loadClassWithTCCL(type.resolvedName);
- val transformer = cls.generatedClass;
- if (transformer !== null) {
- return transformer;
- }
-
- return withClassLoaderAndLock(cls.classLoader, lock) [ |
- val valueTransformer = generateValueTransformer(cls, type);
- return valueTransformer;
- ]
- }
-
- private def generateKeyTransformerFor(Class<? extends Object> inputType, GeneratedType typeSpec, ListSchemaNode node) {
- try {
-
- //log.info("Generating DOM Codec for {} with {}", inputType, inputType.classLoader)
- val properties = typeSpec.allProperties;
- val ctCls = createClass(inputType.codecClassName) [
- //staticField(Map,"AUGMENTATION_SERIALIZERS");
- staticField(it, INSTANCE_IDENTIFIER_CODEC, BindingCodec)
- staticField(it, IDENTITYREF_CODEC, BindingCodec)
- staticQNameField(node.QName);
- implementsType(BINDING_CODEC)
- method(Object, "toDomStatic", QName, Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''
- {
- «QName.name» _resultName;
- if($1 != null) {
- _resultName = «QName.name».create($1,QNAME.getLocalName());
- } else {
- _resultName = QNAME;
- }
- java.util.List _childNodes = new java.util.ArrayList();
- «inputType.resolvedName» value = («inputType.name») $2;
- «FOR key : node.keyDefinition»
- «val propertyName = key.getterName»
- «val keyDef = node.getDataChildByName(key)»
- «val property = properties.get(propertyName)»
- «serializeProperty(keyDef, property, propertyName)»;
- «ENDFOR»
- return ($r) java.util.Collections.singletonMap(_resultName,_childNodes);
- }
- '''
- ]
- method(Object, "fromDomStatic", QName, Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''
- {
- if($2 == null){
- return null;
- }
- «QName.name» _localQName = $1;
- java.util.Map _compositeNode = (java.util.Map) $2;
- boolean _is_empty = true;
- «FOR key : node.keyDefinition»
- «val propertyName = key.getterName»
- «val keyDef = node.getDataChildByName(key)»
- «val property = properties.get(propertyName)»
- «deserializeProperty(keyDef, property, propertyName)»;
- «ENDFOR»
- «inputType.resolvedName» _value = new «inputType.name»(«node.keyDefinition.
- keyConstructorList»);
- return _value;
- }
- '''
- ]
- method(Object, "serialize", Object) [
- bodyChecked = '''
- {
- java.util.Map.Entry _input = (java.util.Map.Entry) $1;
- «QName.name» _localQName = («QName.name») _input.getKey();
- «inputType.name» _keyValue = («inputType.name») _input.getValue();
- return toDomStatic(_localQName,_keyValue);
- }
- '''
- ]
- method(Object, "deserialize", Object) [
- bodyChecked = '''
- return fromDomStatic(QNAME,$1);
- '''
- ]
- ]
- val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
- log.debug("DOM Codec for {} was generated {}", inputType, ret)
- return ret as Class<? extends BindingCodec<Map<QName,Object>, ?>>;
- } catch (Exception e) {
- processException(inputType, e);
- return null;
- }
- }
-
- private def Class<? extends BindingCodec<Object, Object>> generateCaseCodec(Class<?> inputType, GeneratedType type,
- ChoiceCaseNode node) {
- try {
-
- //log.info("Generating DOM Codec for {} with {}, TCCL is: {}", inputType, inputType.classLoader,Thread.currentThread.contextClassLoader)
- val ctCls = createClass(type.codecClassName) [
- //staticField(Map,"AUGMENTATION_SERIALIZERS");
- implementsType(BINDING_CODEC)
- staticQNameField(node.QName);
- staticField(it, INSTANCE_IDENTIFIER_CODEC, BindingCodec)
- staticField(it, AUGMENTATION_CODEC, BindingCodec)
- staticField(it, IDENTITYREF_CODEC, BindingCodec)
- method(Object, "toDomStatic", QName, Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''
- {
- «QName.name» _resultName = «QName.name».create($1,QNAME.getLocalName());
- java.util.List _childNodes = new java.util.ArrayList();
- «type.resolvedName» value = («type.resolvedName») $2;
- «transformDataContainerBody(type, type.allProperties, node)»
- return ($r) _childNodes;
- }
- '''
- ]
- method(Object, "serialize", Object) [
- bodyChecked = '''
- {
- java.util.Map.Entry _input = (java.util.Map.Entry) $1;
- «QName.name» _localName = QNAME;
- if(_input.getKey() != null) {
- _localName = («QName.name») _input.getKey();
- }
- return toDomStatic(_localName,_input.getValue());
- }
- '''
- ]
- method(Object, "fromDomStatic", QName, Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = deserializeBody(type, node)
- ]
- method(Object, "deserialize", Object) [
- bodyChecked = '''
- {
- //System.out.println("«type.name»#deserialize: " +$1);
- java.util.Map.Entry _input = (java.util.Map.Entry) $1;
- return fromDomStatic((«QName.name»)_input.getKey(),_input.getValue());
- }
- '''
- ]
- ]
-
- val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain) as Class<? extends BindingCodec<Object, Object>>
- listener?.onDataContainerCodecCreated(inputType, ret);
- log.debug("DOM Codec for {} was generated {}", inputType, ret)
- return ret;
- } catch (Exception e) {
- processException(inputType, e);
- return null;
- }
- }
-
- private def dispatch Class<? extends BindingCodec<Map<QName, Object>, Object>> generateTransformerFor(
- Class<?> inputType, GeneratedType typeSpec, SchemaNode node) {
- try {
-
- //log.info("Generating DOM Codec for {} with {}", inputType, inputType.classLoader)
- val ctCls = createClass(typeSpec.codecClassName) [
- //staticField(Map,"AUGMENTATION_SERIALIZERS");
- staticQNameField(node.QName);
- staticField(it, INSTANCE_IDENTIFIER_CODEC, BindingCodec)
- staticField(it, IDENTITYREF_CODEC, BindingCodec)
- staticField(it, AUGMENTATION_CODEC, BindingCodec)
- implementsType(BINDING_CODEC)
- method(Object, "toDomStatic", QName, Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = serializeBodyFacade(typeSpec, node)
- ]
- method(Object, "serialize", Object) [
- bodyChecked = '''
- {
- java.util.Map.Entry _input = (java.util.Map.Entry) $1;
- «QName.name» _localName = QNAME;
- if(_input.getKey() != null) {
- _localName = («QName.name») _input.getKey();
- }
- return toDomStatic(_localName,_input.getValue());
- }
- '''
- ]
- method(Object, "fromDomStatic", QName, Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = deserializeBody(typeSpec, node)
- ]
- method(Object, "deserialize", Object) [
- bodyChecked = '''
- return fromDomStatic(QNAME,$1);
- '''
- ]
- ]
-
- val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain) as Class<? extends BindingCodec<Map<QName,Object>, Object>>
- listener?.onDataContainerCodecCreated(inputType, ret);
- log.debug("DOM Codec for {} was generated {}", inputType, ret)
- return ret;
- } catch (Exception e) {
- processException(inputType, e);
- return null;
- }
- }
-
- private def Class<? extends BindingCodec<Map<QName, Object>, Object>> generateAugmentationTransformerFor(
- Class<?> inputType, GeneratedType type, AugmentationSchema node) {
- try {
-
- //log.info("Generating DOM Codec for {} with {}", inputType, inputType.classLoader)
- val properties = type.allProperties
- val ctCls = createClass(type.codecClassName) [
- //staticField(Map,"AUGMENTATION_SERIALIZERS");
- staticQNameField(node.augmentationQName);
- staticField(it, INSTANCE_IDENTIFIER_CODEC, BindingCodec)
- staticField(it, AUGMENTATION_CODEC, BindingCodec)
- staticField(it, IDENTITYREF_CODEC, BindingCodec)
- implementsType(BINDING_CODEC)
- method(Object, "toDomStatic", QName, Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''
- {
- ////System.out.println("Qname " + $1);
- ////System.out.println("Value " + $2);
- «QName.name» _resultName = «QName.name».create(QNAME,QNAME.getLocalName());
- java.util.List _childNodes = new java.util.ArrayList();
- «type.resolvedName» value = («type.resolvedName») $2;
- «FOR child : node.childNodes»
- «var signature = properties.getFor(child)»
- ////System.out.println("«signature.key»" + value.«signature.key»());
- «serializeProperty(child, signature.value, signature.key)»
- «ENDFOR»
- return ($r) _childNodes;
- }
- '''
- ]
- method(Object, "serialize", Object) [
- bodyChecked = '''
- {
- java.util.Map.Entry _input = (java.util.Map.Entry) $1;
- «QName.name» _localName = QNAME;
- if(_input.getKey() != null) {
- _localName = («QName.name») _input.getKey();
- }
- return toDomStatic(_localName,_input.getValue());
- }
- '''
- ]
- method(Object, "fromDomStatic", QName, Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''
- {
- «QName.name» _localQName = QNAME;
-
- if($2 == null) {
- return null;
- }
- java.util.Map _compositeNode = (java.util.Map) $2;
- //System.out.println(_localQName + " " + _compositeNode);
- «type.builderName» _builder = new «type.builderName»();
- boolean _is_empty = true;
- «FOR child : node.childNodes»
- «val signature = properties.getFor(child)»
- «deserializeProperty(child, signature.value, signature.key)»
- _builder.«signature.key.toSetter»(«signature.key»);
- «ENDFOR»
- if(_is_empty) {
- return null;
- }
- return _builder.build();
- }
- '''
- ]
- method(Object, "deserialize", Object) [
- bodyChecked = '''
- return fromDomStatic(QNAME,$1);
- '''
- ]
- ]
-
- val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain) as Class<? extends BindingCodec<Map<QName,Object>, Object>>
- listener?.onDataContainerCodecCreated(inputType, ret);
- return ret;
- } catch (Exception e) {
- processException(inputType, e);
- return null;
- }
- }
-
- private def dispatch Class<? extends BindingCodec<Map<QName, Object>, Object>> generateTransformerFor(
- Class<?> inputType, GeneratedType typeSpec, ChoiceNode node) {
- try {
-
- //log.info("Generating DOM Codec for {} with {}", inputType, inputType.classLoader)
- val ctCls = createClass(typeSpec.codecClassName) [
- //staticField(Map,"AUGMENTATION_SERIALIZERS");
- //staticQNameField(inputType);
- staticField(it, INSTANCE_IDENTIFIER_CODEC, BindingCodec)
- staticField(it, IDENTITYREF_CODEC, BindingCodec)
- staticField(it, CLASS_TO_CASE_MAP, Map)
- staticField(it, COMPOSITE_TO_CASE, Map)
- //staticField(it,QNAME_TO_CASE_MAP,BindingCodec)
- implementsType(BINDING_CODEC)
- method(List, "toDomStatic", QName, Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''
- {
- if($2 == null) {
- return null;
- }
- «DataObject.name» _baValue = («DataObject.name») $2;
- Class _baClass = _baValue.getImplementedInterface();
- «BINDING_CODEC.name» _codec = «CLASS_TO_CASE_MAP».get(_baClass);
- if(_codec == null) {
- return null;
- }
- java.util.Map.Entry _input = new «SimpleEntry.name»($1,_baValue);
- Object _ret = _codec.serialize(_input);
- ////System.out.println("«typeSpec.name»#toDomStatic: " + _ret);
- return («List.name») _ret;
- }
- '''
- ]
- method(Object, "serialize", Object) [
- bodyChecked = '''
- throw new «UnsupportedOperationException.name»("Direct invocation not supported.");
- '''
- ]
- method(Object, "fromDomStatic", QName, Map) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''
- {
- «BINDING_CODEC.name» _codec = («BINDING_CODEC.name») «COMPOSITE_TO_CASE».get($2);
- if(_codec != null) {
- return _codec.deserialize(new «SimpleEntry.name»($1,$2));
- }
- return null;
- }
- '''
- ]
- method(Object, "deserialize", Object) [
- bodyChecked = '''
- throw new «UnsupportedOperationException.name»("Direct invocation not supported.");
- '''
- ]
- ]
-
- val rawRet = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
- val ret = rawRet as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- listener?.onChoiceCodecCreated(inputType, ret, node);
- log.debug("DOM Codec for {} was generated {}", inputType, ret)
- return ret;
- } catch (Exception e) {
- processException(inputType, e);
- return null;
- }
- }
-
- private def keyConstructorList(List<QName> qnames) {
- val names = new TreeSet<String>()
- for (name : qnames) {
- val fieldName = name.getterName;
- names.add(fieldName);
- }
- return Joiner.on(",").join(names);
- }
-
- private def serializeBodyFacade(GeneratedType type, SchemaNode node) {
- val ret = serializeBody(type, node);
- return ret;
- }
-
- private def String deserializeBody(GeneratedType type, SchemaNode node) {
- val ret = deserializeBodyImpl(type, node);
- return ret;
- }
-
- private def deserializeKey(GeneratedType type, ListSchemaNode node) {
- if (node.keyDefinition != null && !node.keyDefinition.empty) {
- return '''
- «type.resolvedName»Key getKey = («type.resolvedName»Key) «keyTransformer(type, node).canonicalName».fromDomStatic(_localQName,_compositeNode);
- _builder.setKey(getKey);
- ''';
- }
- }
-
- private def dispatch String deserializeBodyImpl(GeneratedType type, SchemaNode node) '''
- {
- «QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
-
- if($2 == null) {
- return null;
- }
- java.util.Map _compositeNode = (java.util.Map) $2;
- «type.builderName» _builder = new «type.builderName»();
- return _builder.build();
- }
- '''
-
- private def dispatch String deserializeBodyImpl(GeneratedType type, ListSchemaNode node) '''
- {
- «QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
- if($2 == null) {
- return null;
- }
- java.util.Map _compositeNode = (java.util.Map) $2;
- //System.out.println(_localQName + " " + _compositeNode);
- «type.builderName» _builder = new «type.builderName»();
- «deserializeKey(type, node)»
- «deserializeDataNodeContainerBody(type, node)»
- «deserializeAugmentations»
- return _builder.build();
- }
- '''
-
- private def dispatch String deserializeBodyImpl(GeneratedType type, ContainerSchemaNode node) '''
- {
- «QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
- if($2 == null) {
- return null;
- }
- java.util.Map _compositeNode = (java.util.Map) $2;
- //System.out.println(_localQName + " " + _compositeNode);
- «type.builderName» _builder = new «type.builderName»();
- «deserializeDataNodeContainerBody(type, node)»
- «deserializeAugmentations»
- return _builder.build();
- }
- '''
-
- private def dispatch String deserializeBodyImpl(GeneratedType type, ChoiceCaseNode node) '''
- {
- «QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
-
- if($2 == null) {
- return null;
- }
- java.util.Map _compositeNode = (java.util.Map) $2;
- //System.out.println(_localQName + " " + _compositeNode);
- «type.builderName» _builder = new «type.builderName»();
- «deserializeDataNodeContainerBody(type, node)»
- «deserializeAugmentations»
- return _builder.build();
- }
- '''
-
- private def deserializeDataNodeContainerBody(GeneratedType type, DataNodeContainer node) {
- deserializeNodeContainerBodyImpl(type, type.allProperties, node);
- }
-
- private def deserializeNodeContainerBodyImpl(GeneratedType type, HashMap<String, Type> properties,
- DataNodeContainer node) {
- val ret = '''
- boolean _is_empty = true;
- «FOR child : node.childNodes»
- «val signature = properties.getFor(child)»
- «IF signature !== null»
- «deserializeProperty(child, signature.value, signature.key)»
- _builder.«signature.key.toSetter»(«signature.key»);
- «ENDIF»
- «ENDFOR»
- '''
- return ret;
- }
-
- def deserializeAugmentations() '''
- java.util.Map _augmentation = (java.util.Map) «AUGMENTATION_CODEC».deserialize(_compositeNode);
- if(_augmentation != null) {
- «Iterator.name» _entries = _augmentation.entrySet().iterator();
- while(_entries.hasNext()) {
- java.util.Map.Entry _entry = (java.util.Map.Entry) _entries.next();
- ////System.out.println("Aug. key:" + _entry.getKey());
- Class _type = (Class) _entry.getKey();
- «Augmentation.resolvedName» _value = («Augmentation.name») _entry.getValue();
- if(_value != null) {
- _builder.addAugmentation(_type,_value);
- }
- }
- }
- '''
-
- private def dispatch CharSequence deserializeProperty(ListSchemaNode schema, ParameterizedType type,
- String propertyName) '''
- java.util.List _dom_«propertyName» = _compositeNode.get(«QName.name».create(_localQName,"«schema.QName.
- localName»"));
- ////System.out.println("«propertyName»#deCode"+_dom_«propertyName»);
- java.util.List «propertyName» = new java.util.ArrayList();
- if(_dom_«propertyName» != null) {
- java.util.List _serialized = new java.util.ArrayList();
- java.util.Iterator _iterator = _dom_«propertyName».iterator();
- boolean _hasNext = _iterator.hasNext();
- while(_hasNext) {
- Object _listItem = _iterator.next();
- _is_empty = false;
- ////System.out.println(" item" + _listItem);
- Object _value = «type.actualTypeArguments.get(0).serializer(schema).resolvedName».fromDomStatic(_localQName,_listItem);
- ////System.out.println(" value" + _value);
- «propertyName».add(_value);
- _hasNext = _iterator.hasNext();
- }
- }
-
- ////System.out.println(" list" + «propertyName»);
- '''
-
- private def dispatch CharSequence deserializeProperty(LeafListSchemaNode schema, ParameterizedType type,
- String propertyName) '''
- java.util.List _dom_«propertyName» = _compositeNode.get(«QName.name».create(_localQName,"«schema.QName.
- localName»"));
- java.util.List «propertyName» = new java.util.ArrayList();
- if(_dom_«propertyName» != null) {
- java.util.List _serialized = new java.util.ArrayList();
- java.util.Iterator _iterator = _dom_«propertyName».iterator();
- boolean _hasNext = _iterator.hasNext();
- while(_hasNext) {
- _is_empty = false;
- Object _listItem = _iterator.next();
- if(_listItem instanceof java.util.Map.Entry) {
- Object _innerValue = ((java.util.Map.Entry) _listItem).getValue();
- Object _value = «deserializeValue(type.actualTypeArguments.get(0), "_innerValue", schema.type)»;
- «propertyName».add(_value);
- }
- _hasNext = _iterator.hasNext();
- }
- }
- '''
-
- private def dispatch CharSequence deserializeProperty(LeafSchemaNode schema, Type type, String propertyName) '''
- java.util.List _dom_«propertyName»_list =
- _compositeNode.get(«QName.name».create(_localQName,"«schema.QName.localName»"));
- «type.resolvedName» «propertyName» = null;
- if(_dom_«propertyName»_list != null && _dom_«propertyName»_list.size() > 0) {
- _is_empty = false;
- java.util.Map.Entry _dom_«propertyName» = (java.util.Map.Entry) _dom_«propertyName»_list.get(0);
- Object _inner_value = _dom_«propertyName».getValue();
- «propertyName» = «deserializeValue(type, "_inner_value", schema.type)»;
- }
- '''
-
- private def dispatch CharSequence deserializeProperty(ContainerSchemaNode schema, Type type,
- String propertyName) '''
- java.util.List _dom_«propertyName»_list =
- _compositeNode.get(«QName.name».create(_localQName,"«schema.QName.localName»"));
- «type.resolvedName» «propertyName» = null;
- if(_dom_«propertyName»_list != null && _dom_«propertyName»_list.size() > 0) {
- _is_empty = false;
- java.util.Map _dom_«propertyName» = (java.util.Map) _dom_«propertyName»_list.get(0);
- «propertyName» = «type.serializer(schema).resolvedName».fromDomStatic(_localQName,_dom_«propertyName»);
- }
- '''
-
- private def dispatch CharSequence deserializeProperty(ChoiceNode schema, Type type, String propertyName) '''
- «type.resolvedName» «propertyName» = «type.serializer(schema).resolvedName».fromDomStatic(_localQName,_compositeNode);
- if(«propertyName» != null) {
- _is_empty = false;
- }
- '''
-
- private def dispatch String deserializeValue(GeneratedTransferObject type, String domParameter,
- TypeDefinition<?> typeDefinition) '''
- («type.resolvedName») «type.valueSerializer(typeDefinition).resolvedName».fromDomValue(«domParameter»)
- '''
-
- private def dispatch String deserializeValue(Enumeration type, String domParameter, TypeDefinition<?> typeDefinition) '''
- («type.resolvedName») «type.valueSerializer(typeDefinition).resolvedName».fromDomValue(«domParameter»)
- '''
-
- private def dispatch Class<? extends BindingCodec<Map<QName, Object>, Object>> generateValueTransformer(
- Class<?> inputType, GeneratedTransferObject typeSpec, TypeDefinition<?> typeDef) {
- try {
-
- val returnType = typeSpec.valueReturnType;
- if (returnType == null) {
- val ctCls = createDummyImplementation(inputType, typeSpec);
- val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
- return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- }
-
- val ctCls = createClass(typeSpec.codecClassName) [
- //staticField(Map,"AUGMENTATION_SERIALIZERS");
- if (inputType.isYangBindingAvailable) {
- implementsType(BINDING_CODEC)
- staticField(it, INSTANCE_IDENTIFIER_CODEC, BindingCodec)
- staticField(it, IDENTITYREF_CODEC, BindingCodec)
- implementsType(BindingDeserializer.asCtClass)
- }
- method(Object, "toDomValue", Object) [
- modifiers = PUBLIC + FINAL + STATIC
- val ctSpec = typeSpec.asCtClass;
- bodyChecked = '''
- {
- ////System.out.println("«inputType.simpleName»#toDomValue: "+$1);
-
- if($1 == null) {
- return null;
- }
- «typeSpec.resolvedName» _encapsulatedValue = («typeSpec.resolvedName») $1;
- ////System.out.println("«inputType.simpleName»#toDomValue:Enc: "+_encapsulatedValue);
- «returnType.resolvedName» _value = _encapsulatedValue.getValue();
- ////System.out.println("«inputType.simpleName»#toDomValue:DeEnc: "+_value);
- Object _domValue = «serializeValue(returnType, "_value", null)»;
- return _domValue;
- }
- '''
- ]
- method(Object, "serialize", Object) [
- bodyChecked = '''
- {
- return toDomValue($1);
- }
- '''
- ]
- method(Object, "fromDomValue", Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''
- {
- ////System.out.println("«inputType.simpleName»#fromDomValue: "+$1);
-
- if($1 == null) {
- return null;
- }
- «returnType.resolvedName» _simpleValue = «deserializeValue(returnType, "$1", null)»;
- «typeSpec.resolvedName» _value = new «typeSpec.resolvedName»(_simpleValue);
- return _value;
- }
- '''
- ]
- method(Object, "deserialize", Object) [
- bodyChecked = '''{
- return fromDomValue($1);
- }
- '''
- ]
- ]
-
- val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
- log.debug("DOM Codec for {} was generated {}", inputType, ret)
- return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- } catch (Exception e) {
- log.error("Cannot compile DOM Codec for {}", inputType, e);
- val exception = new CodeGenerationException("Cannot compile Transformator for " + inputType);
- exception.addSuppressed(e);
- throw exception;
- }
- }
-
- private def dispatch Class<? extends BindingCodec<Map<QName, Object>, Object>> generateValueTransformer(
- Class<?> inputType, GeneratedTransferObject typeSpec, UnionTypeDefinition typeDef) {
- try {
- val ctCls = createClass(typeSpec.codecClassName) [
- val properties = typeSpec.allProperties;
- val getterToTypeDefinition = XtendHelper.getTypes(typeDef).toMap[type | type.QName.getterName];
- //staticField(Map,"AUGMENTATION_SERIALIZERS");
- if (inputType.isYangBindingAvailable) {
- implementsType(BINDING_CODEC)
- staticField(it, INSTANCE_IDENTIFIER_CODEC, BindingCodec)
- staticField(it, IDENTITYREF_CODEC, BindingCodec)
- implementsType(BindingDeserializer.asCtClass)
- }
- method(Object, "toDomValue", Object) [
- modifiers = PUBLIC + FINAL + STATIC
- val ctSpec = inputType.asCtClass;
-
- bodyChecked = '''
- {
- ////System.out.println("«inputType.simpleName»#toDomValue: "+$1);
-
- if($1 == null) {
- return null;
- }
- «typeSpec.resolvedName» _value = («typeSpec.resolvedName») $1;
- «FOR property : properties.entrySet»
- «IF property.key != "getValue"»
- «property.value.resolvedName» «property.key» = («property.value.resolvedName») _value.«property.
- key»();
- if(«property.key» != null) {
- return «serializeValue(property.value, property.key, getterToTypeDefinition.get(property.key))»;
- }
- «ENDIF»
- «ENDFOR»
-
- return null;
- }
- '''
- ]
- method(Object, "serialize", Object) [
- bodyChecked = '''
- {
- return toDomValue($1);
- }
- '''
- ]
- method(Object, "fromDomValue", Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''
- {
- ////System.out.println("«inputType.simpleName»#fromDomValue: "+$1);
-
- if($1 == null) {
- return null;
- }
- if($1 instanceof String) {
- String _simpleValue = (String) $1;
- return new «typeSpec.resolvedName»(_simpleValue.toCharArray());
- }
- return null;
- }
- '''
- ]
- method(Object, "deserialize", Object) [
- bodyChecked = '''{
- return fromDomValue($1);
- }
- '''
- ]
- ]
-
- val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
- log.debug("DOM Codec for {} was generated {}", inputType, ret)
- return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- } catch (Exception e) {
- log.error("Cannot compile DOM Codec for {}", inputType, e);
- val exception = new CodeGenerationException("Cannot compile Transformator for " + inputType);
- exception.addSuppressed(e);
- throw exception;
- }
- }
-
-
- private def dispatch Class<? extends BindingCodec<Map<QName, Object>, Object>> generateValueTransformer(
- Class<?> inputType, GeneratedTransferObject typeSpec, BitsTypeDefinition typeDef) {
- try {
- val ctCls = createClass(typeSpec.codecClassName) [
- //staticField(Map,"AUGMENTATION_SERIALIZERS");
- if (inputType.isYangBindingAvailable) {
- implementsType(BINDING_CODEC)
- staticField(it, INSTANCE_IDENTIFIER_CODEC, BindingCodec)
- staticField(it, IDENTITYREF_CODEC, BindingCodec)
- implementsType(BindingDeserializer.asCtClass)
- }
- method(Object, "toDomValue", Object) [
- modifiers = PUBLIC + FINAL + STATIC
- val ctSpec = typeSpec.asCtClass;
- bodyChecked = '''
- {
- ////System.out.println("«inputType.simpleName»#toDomValue: "+$1);
-
- if($1 == null) {
- return null;
- }
- «typeSpec.resolvedName» _encapsulatedValue = («typeSpec.resolvedName») $1;
- «HashSet.resolvedName» _value = new «HashSet.resolvedName»();
- //System.out.println("«inputType.simpleName»#toDomValue:Enc: "+_encapsulatedValue);
-
- «FOR bit : typeDef.bits»
- «val getter = bit.getterName()»
- if(Boolean.TRUE.equals(_encapsulatedValue.«getter»())) {
- _value.add("«bit.name»");
- }
- «ENDFOR»
- «Set.resolvedName» _domValue = «Collections.resolvedName».unmodifiableSet(_value);
- //System.out.println("«inputType.simpleName»#toDomValue:DeEnc: "+_domValue);
-
- return _domValue;
- }
- '''
- ]
- method(Object, "serialize", Object) [
- bodyChecked = '''
- {
- return toDomValue($1);
- }
- '''
- ]
- method(Object, "fromDomValue", Object) [
- modifiers = PUBLIC + FINAL + STATIC
- val sortedBits = typeDef.bits.sort[o1, o2|o1.propertyName.compareTo(o2.propertyName)]
- bodyChecked = '''
- {
- //System.out.println("«inputType.simpleName»#fromDomValue: "+$1);
-
- if($1 == null) {
- return null;
- }
- «Set.resolvedName» _domValue = («Set.resolvedName») $1;
- «FOR bit : sortedBits»
- Boolean «bit.propertyName» = Boolean.valueOf(_domValue.contains("«bit.name»"));
- «ENDFOR»
-
- return new «inputType.resolvedName»(«FOR bit : sortedBits SEPARATOR ","»«bit.propertyName»«ENDFOR»);
- }
- '''
- ]
- method(Object, "deserialize", Object) [
- bodyChecked = '''{
- return fromDomValue($1);
- }
- '''
- ]
- ]
-
- val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
- log.debug("DOM Codec for {} was generated {}", inputType, ret)
- return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
- } catch (Exception e) {
- log.error("Cannot compile DOM Codec for {}", inputType, e);
- val exception = new CodeGenerationException("Cannot compile Transformator for " + inputType);
- exception.addSuppressed(e);
- throw exception;
- }
- }
-
- def String getPropertyName(Bit bit) {
- '''_«BindingGeneratorUtil.parseToValidParamName(bit.name)»'''
- }
-
- def String getterName(Bit bit) {
-
- val paramName = BindingGeneratorUtil.parseToValidParamName(bit.name);
- return '''is«paramName.toFirstUpper»''';
- }
-
- def boolean isYangBindingAvailable(Class<?> class1) {
- try {
- val bindingCodecClass = class1.classLoader.loadClass(BINDING_CODEC.name);
- return bindingCodecClass !== null;
- } catch (ClassNotFoundException e) {
- return false;
- }
- }
-
- private def createDummyImplementation(Class<?> object, GeneratedTransferObject typeSpec) {
- log.trace("Generating Dummy DOM Codec for {} with {}", object, object.classLoader)
- return createClass(typeSpec.codecClassName) [
- if (object.isYangBindingAvailable) {
- implementsType(BINDING_CODEC)
- staticField(it, INSTANCE_IDENTIFIER_CODEC, BindingCodec)
- staticField(it, IDENTITYREF_CODEC, BindingCodec)
- implementsType(BindingDeserializer.asCtClass)
- }
- //implementsType(BindingDeserializer.asCtClass)
- method(Object, "toDomValue", Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''{
- if($1 == null) {
- return null;
- }
- return $1.toString();
-
- }'''
- ]
- method(Object, "serialize", Object) [
- bodyChecked = '''
- {
- return toDomValue($1);
- }
- '''
- ]
- method(Object, "fromDomValue", Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''return null;'''
- ]
- method(Object, "deserialize", Object) [
- bodyChecked = '''{
- return fromDomValue($1);
- }
- '''
- ]
- ]
- }
-
- private def Type getValueReturnType(GeneratedTransferObject object) {
- for (prop : object.properties) {
- if (prop.name == "value") {
- return prop.returnType;
- }
- }
- if (object.superType != null) {
- return getValueReturnType(object.superType);
- }
- return null;
- }
-
- private def Class<?> generateValueTransformer(Class<?> inputType, Enumeration typeSpec) {
- try {
- val typeRef = new ReferencedTypeImpl(typeSpec.packageName, typeSpec.name);
- val schema = typeToSchemaNode.get(typeRef) as ExtendedType;
- val enumSchema = schema.baseType as EnumerationType;
-
- //log.info("Generating DOM Codec for {} with {}", inputType, inputType.classLoader)
- val ctCls = createClass(typeSpec.codecClassName) [
- //staticField(Map,"AUGMENTATION_SERIALIZERS");
- //implementsType(BINDING_CODEC)
- method(Object, "toDomValue", Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''{
- if($1 == null) {
- return null;
- }
- «typeSpec.resolvedName» _value = («typeSpec.resolvedName») $1;
- «FOR en : enumSchema.values»
- if(«typeSpec.resolvedName».«BindingGeneratorUtil.parseToClassName(en.name)».equals(_value)) {
- return "«en.name»";
- }
- «ENDFOR»
- return null;
- }
- '''
- ]
- method(Object, "serialize", Object) [
- bodyChecked = '''
- return toDomValue($1);
- '''
- ]
- method(Object, "fromDomValue", Object) [
- modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = '''
- {
- if($1 == null) {
- return null;
- }
- String _value = (String) $1;
- «FOR en : enumSchema.values»
- if("«en.name»".equals(_value)) {
- return «typeSpec.resolvedName».«BindingGeneratorUtil.parseToClassName(en.name)»;
- }
- «ENDFOR»
- return null;
- }
- '''
- ]
- method(Object, "deserialize", Object) [
- bodyChecked = '''
- return fromDomValue($1);
- '''
- ]
- ]
-
- val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
- log.debug("DOM Codec for {} was generated {}", inputType, ret)
- return ret;
- } catch (CodeGenerationException e) {
- throw new CodeGenerationException("Cannot compile Transformator for " + inputType, e);
- } catch (Exception e) {
- log.error("Cannot compile DOM Codec for {}", inputType, e);
- val exception = new CodeGenerationException("Cannot compile Transformator for " + inputType);
- exception.addSuppressed(e);
- throw exception;
- }
-
- }
-
- def Class<?> toClassImpl(CtClass newClass, ClassLoader loader, ProtectionDomain domain) {
- val cls = newClass.toClass(loader, domain);
- if (classFileCapturePath !== null) {
- newClass.writeFile(classFileCapturePath.absolutePath);
- }
- listener?.onCodecCreated(cls);
- return cls;
- }
-
- def debugWriteClass(CtClass class1) {
- val path = class1.name.replace(".", "/") + ".class"
-
- val captureFile = new File(classFileCapturePath, path);
- captureFile.createNewFile
-
- }
-
- private def dispatch String deserializeValue(Type type, String domParameter, TypeDefinition<?> typeDef) {
- if (INSTANCE_IDENTIFIER.equals(type)) {
- return '''(«InstanceIdentifier.name») «INSTANCE_IDENTIFIER_CODEC».deserialize(«domParameter»)'''
- } else if (CLASS_TYPE.equals(type)) {
- return '''(«Class.name») «IDENTITYREF_CODEC».deserialize(«domParameter»)'''
- }
- return '''(«type.resolvedName») «domParameter»'''
-
- }
-
- /**
- * Default catch all
- *
- **/
- private def dispatch CharSequence deserializeProperty(DataSchemaNode container, Type type, String propertyName) '''
- «type.resolvedName» «propertyName» = null;
- '''
-
- private def dispatch CharSequence deserializeProperty(DataSchemaNode container, GeneratedTypeBuilder type,
- String propertyName) {
- _deserializeProperty(container, type.toInstance, propertyName)
- }
-
- public static def toSetter(String it) {
-
- if (startsWith("is")) {
- return "set" + substring(2);
- } else if (startsWith("get")) {
- return "set" + substring(3);
- }
- return "set" + it;
- }
-
- /*
- private def dispatch CharSequence deserializeProperty(DataSchemaNode container,GeneratedType type, String propertyName) '''
- «type.resolvedName» «propertyName» = value.«propertyName»();
- if(«propertyName» != null) {
- Object domValue = «type.serializer».toDomStatic(QNAME,«propertyName»);
- _childNodes.add(domValue);
- }
- '''
- */
- private def getBuilderName(GeneratedType type) '''«type.resolvedName»Builder'''
-
- private def staticQNameField(CtClass it, QName node) {
- val field = new CtField(ctQName, "QNAME", it);
- field.modifiers = PUBLIC + FINAL + STATIC;
- addField(field,
- '''«QName.asCtClass.name».create("«node.namespace»","«node.formattedRevision»","«node.localName»")''')
- }
-
- private def dispatch String serializeBody(GeneratedType type, ListSchemaNode node) '''
- {
- «QName.name» _resultName = «QName.name».create($1,QNAME.getLocalName());
- java.util.List _childNodes = new java.util.ArrayList();
- «type.resolvedName» value = («type.resolvedName») $2;
- «transformDataContainerBody(type, type.allProperties, node)»
- «serializeAugmentations»
- return ($r) java.util.Collections.singletonMap(_resultName,_childNodes);
- }
- '''
-
- private def dispatch String serializeBody(GeneratedType type, ContainerSchemaNode node) '''
- {
- «QName.name» _resultName = «QName.name».create($1,QNAME.getLocalName());
- java.util.List _childNodes = new java.util.ArrayList();
- «type.resolvedName» value = («type.resolvedName») $2;
- «transformDataContainerBody(type, type.allProperties, node)»
- «serializeAugmentations»
- return ($r) java.util.Collections.singletonMap(_resultName,_childNodes);
- }
- '''
-
- private def dispatch String serializeBody(GeneratedType type, ChoiceCaseNode node) '''
- {
- «QName.name» _resultName = «QName.name».create($1,QNAME.getLocalName());
- java.util.List _childNodes = new java.util.ArrayList();
- «type.resolvedName» value = («type.resolvedName») $2;
- «transformDataContainerBody(type, type.allProperties, node)»
- «serializeAugmentations»
- return ($r) java.util.Collections.singletonMap(_resultName,_childNodes);
- }
- '''
-
- private def dispatch String serializeBody(GeneratedType type, SchemaNode node) '''
- {
- «QName.name» _resultName = «QName.name».create($1,QNAME.getLocalName());
- java.util.List _childNodes = new java.util.ArrayList();
- «type.resolvedName» value = («type.resolvedName») $2;
- return ($r) java.util.Collections.singletonMap(_resultName,_childNodes);
- }
- '''
-
- private def transformDataContainerBody(Type type, Map<String, Type> properties, DataNodeContainer node) {
- val ret = '''
- «FOR child : node.childNodes»
- «val signature = properties.getFor(child)»
- «IF signature !== null»
- ////System.out.println("«type.name»#«signature.key»" + value.«signature.key»());
- «serializeProperty(child, signature.value, signature.key)»
- «ENDIF»
- «ENDFOR»
- '''
- return ret;
- }
-
- private def serializeAugmentations() '''
- java.util.List _augmentations = (java.util.List) «AUGMENTATION_CODEC».serialize(value);
- if(_augmentations != null) {
- _childNodes.addAll(_augmentations);
- }
- '''
-
- def Entry<String, Type> getFor(Map<String, Type> map, DataSchemaNode node) {
- var sig = map.get(node.getterName);
- if (sig != null) {
- return new SimpleEntry(node.getterName, sig);
- }
- sig = map.get(node.booleanGetterName);
- if (sig != null) {
- return new SimpleEntry(node.booleanGetterName, map.get(node.booleanGetterName));
- }
- return null;
- }
-
- private static def String getBooleanGetterName(DataSchemaNode node) {
- return "is" + BindingGeneratorUtil.parseToClassName(node.QName.localName);
- }
-
- private static def String getGetterName(DataSchemaNode node) {
- return "get" + BindingGeneratorUtil.parseToClassName(node.QName.localName);
- }
-
- private static def String getGetterName(QName node) {
- return "get" + BindingGeneratorUtil.parseToClassName(node.localName);
- }
-
- private def dispatch CharSequence serializeProperty(ListSchemaNode schema, ParameterizedType type,
- String propertyName) '''
- «type.resolvedName» «propertyName» = value.«propertyName»();
- ////System.out.println("«propertyName»:" + «propertyName»);
- if(«propertyName» != null) {
- java.util.Iterator _iterator = «propertyName».iterator();
- boolean _hasNext = _iterator.hasNext();
- while(_hasNext) {
- Object _listItem = _iterator.next();
- Object _domValue = «type.actualTypeArguments.get(0).serializer(schema).resolvedName».toDomStatic(_resultName,_listItem);
- _childNodes.add(_domValue);
- _hasNext = _iterator.hasNext();
- }
- }
- '''
-
- private def dispatch CharSequence serializeProperty(LeafSchemaNode schema, Type type, String propertyName) '''
- «type.resolvedName» «propertyName» = value.«propertyName»();
-
- if(«propertyName» != null) {
- «QName.name» _qname = «QName.name».create(_resultName,"«schema.QName.localName»");
- Object _propValue = «serializeValue(type, propertyName, schema.type)»;
- if(_propValue != null) {
- Object _domValue = java.util.Collections.singletonMap(_qname,_propValue);
- _childNodes.add(_domValue);
- }
- }
- '''
-
- private def dispatch serializeValue(GeneratedTransferObject type, String parameter, TypeDefinition<?> typeDefinition) {
- '''«type.valueSerializer(typeDefinition).resolvedName».toDomValue(«parameter»)'''
- }
-
- private def dispatch serializeValue(Enumeration type, String parameter, TypeDefinition<?> typeDefinition) {
- '''«type.valueSerializer(typeDefinition).resolvedName».toDomValue(«parameter»)'''
- }
-
- private def dispatch serializeValue(Type signature, String property, TypeDefinition<?> typeDefinition) {
- if (INSTANCE_IDENTIFIER == signature) {
- return '''«INSTANCE_IDENTIFIER_CODEC».serialize(«property»)'''
- } else if (CLASS_TYPE.equals(signature)) {
- return '''(«QName.resolvedName») «IDENTITYREF_CODEC».serialize(«property»)'''
- }
- if ("char[]" == signature.name) {
- return '''new String(«property»)''';
- }
- return '''«property»''';
- }
-
- private def dispatch CharSequence serializeProperty(LeafListSchemaNode schema, ParameterizedType type,
- String propertyName) '''
- «type.resolvedName» «propertyName» = value.«propertyName»();
- if(«propertyName» != null) {
- «QName.name» _qname = «QName.name».create(_resultName,"«schema.QName.localName»");
- java.util.Iterator _iterator = «propertyName».iterator();
- boolean _hasNext = _iterator.hasNext();
- while(_hasNext) {
- Object _listItem = _iterator.next();
- Object _propValue = «serializeValue(type.actualTypeArguments.get(0), "_listItem", schema.type)»;
- Object _domValue = java.util.Collections.singletonMap(_qname,_propValue);
- _childNodes.add(_domValue);
- _hasNext = _iterator.hasNext();
- }
- }
- '''
-
- private def dispatch CharSequence serializeProperty(ChoiceNode container, GeneratedType type,
- String propertyName) '''
- «type.resolvedName» «propertyName» = value.«propertyName»();
- if(«propertyName» != null) {
- java.util.List domValue = «type.serializer(container).resolvedName».toDomStatic(_resultName,«propertyName»);
- _childNodes.addAll(domValue);
- }
- '''
-
- /**
- * Default catch all
- *
- **/
- private def dispatch CharSequence serializeProperty(DataSchemaNode container, Type type, String propertyName) '''
- «type.resolvedName» «propertyName» = value.«propertyName»();
- if(«propertyName» != null) {
- Object domValue = «propertyName»;
- _childNodes.add(domValue);
- }
- '''
-
- private def dispatch CharSequence serializeProperty(DataSchemaNode container, GeneratedTypeBuilder type,
- String propertyName) {
- serializeProperty(container, type.toInstance, propertyName)
- }
-
- private def dispatch CharSequence serializeProperty(DataSchemaNode container, GeneratedType type,
- String propertyName) '''
- «type.resolvedName» «propertyName» = value.«propertyName»();
- if(«propertyName» != null) {
- Object domValue = «type.serializer(container).resolvedName».toDomStatic(_resultName,«propertyName»);
- _childNodes.add(domValue);
- }
- '''
-
- private def codecClassName(GeneratedType typeSpec) {
- return '''«typeSpec.resolvedName»$Broker$Codec$DOM'''
- }
-
- private def codecClassName(Class<?> typeSpec) {
- return '''«typeSpec.name»$Broker$Codec$DOM'''
- }
-
- private def HashMap<String, Type> getAllProperties(GeneratedType type) {
- val ret = new HashMap<String, Type>();
- type.collectAllProperties(ret);
- return ret;
- }
-
- private def dispatch void collectAllProperties(GeneratedType type, Map<String, Type> set) {
- for (definition : type.methodDefinitions) {
- set.put(definition.name, definition.returnType);
- }
- for (property : type.properties) {
- set.put(property.getterName, property.returnType);
- }
- for (parent : type.implements) {
- parent.collectAllProperties(set);
- }
- }
-
- def String getGetterName(GeneratedProperty property) {
- return "get" + property.name.toFirstUpper
- }
-
- private def dispatch void collectAllProperties(Type type, Map<String, Type> set) {
- // NOOP for generic type.
- }
-
- def String getResolvedName(Type type) {
- return type.asCtClass.name;
- }
-
- def String getResolvedName(Class<?> type) {
- return type.asCtClass.name;
- }
-
- def CtClass asCtClass(Type type) {
- val cls = loadClassWithTCCL(type.fullyQualifiedName)
- return cls.asCtClass;
- }
-
- private def dispatch processException(Class<?> inputType, CodeGenerationException e) {
- log.error("Cannot compile DOM Codec for {}. One of it's prerequisites was not generated.", inputType);
- throw e;
- }
-
- private def dispatch processException(Class<?> inputType, Exception e) {
- log.error("Cannot compile DOM Codec for {}", inputType, e);
- val exception = new CodeGenerationException("Cannot compile Transformator for " + inputType, e);
- throw exception;
- }
-
- private def setBodyChecked(CtMethod method, String body) {
- try {
- method.setBody(body);
- } catch (CannotCompileException e) {
- log.error("Cannot compile method: {}#{} {}, Reason: {} Body: {}", method.declaringClass, method.name,
- method.signature, e.message, body)
- throw e;
- }
- }
-
- private def <V> V withClassLoaderAndLock(ClassLoader cls, Lock lock, Callable<V> function) throws Exception {
- appendClassLoaderIfMissing(cls);
- ClassLoaderUtils.withClassLoaderAndLock(cls, lock, function);
- }
-
-}
-
-@Data
-class PropertyPair {
-
- String getterName;
-
- Type type;
-
- @Property
- Type returnType;
- @Property
- SchemaNode schemaNode;
-}
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
import org.opendaylight.controller.sal.binding.impl.RootBindingAwareBroker;
import org.opendaylight.controller.sal.core.api.Broker.ProviderSession;
import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry;
connector.setMappingService(source.getMappingService());
return connector;
}
-
+
public static void startDataForwarding(BindingIndependentConnector connector, DataProviderService baService,
ProviderSession domContext) {
startDataForwarding(connector, baService,
startRpcForwarding(connector, rpcProviderRegistry, domProviderContext.getService(RpcProvisionRegistry.class));
}
-
+
public static void startNotificationForwarding(BindingIndependentConnector connector, NotificationProviderService provider,ProviderSession domProviderContext) {
startNotificationForwarding(connector, provider, domProviderContext.getService(NotificationPublishService.class));
}
connector.setDomDataService(domService);
connector.startDataForwarding();
}
-
+
public static void startNotificationForwarding(BindingIndependentConnector connector, NotificationProviderService baService, NotificationPublishService domService) {
if(connector.isNotificationForwarding()) {
return;
}
-
+
// FIXME
}
import org.opendaylight.controller.sal.binding.api.data.RuntimeDataProvider;
import org.opendaylight.controller.sal.binding.api.rpc.RpcContextIdentifier;
import org.opendaylight.controller.sal.binding.api.rpc.RpcRouter;
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
+import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
import org.opendaylight.controller.sal.binding.impl.RpcProviderRegistryImpl;
import org.opendaylight.controller.sal.binding.impl.RpcProviderRegistryImpl.GlobalRpcRegistrationListener;
import org.opendaylight.controller.sal.binding.impl.RpcProviderRegistryImpl.RouterInstantiationListener;
.builder().toInstance();
private final static Method EQUALS_METHOD;
-
-
+
+
private BindingIndependentMappingService mappingService;
private org.opendaylight.controller.sal.core.api.data.DataProviderService biDataService;
private RpcProviderRegistryImpl baRpcRegistryImpl;
private org.opendaylight.controller.sal.dom.broker.spi.RpcRouter biRouter;
-
-
+
+
static {
try {
EQUALS_METHOD = Object.class.getMethod("equals", Object.class);
}
private class DomToBindingCommitHandler implements //
- RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier<?>, DataObject>>, //
+ RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier<? extends DataObject>, DataObject>>, //
DataCommitHandler<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> {
@Override
- public void onRegister(DataCommitHandlerRegistration<InstanceIdentifier<?>, DataObject> registration) {
+ public void onRegister(DataCommitHandlerRegistration<InstanceIdentifier<? extends DataObject>, DataObject> registration) {
org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath = mappingService.toDataDom(registration
.getPath());
}
@Override
- public void onUnregister(DataCommitHandlerRegistration<InstanceIdentifier<?>, DataObject> registration) {
+ public void onUnregister(DataCommitHandlerRegistration<InstanceIdentifier<? extends DataObject>, DataObject> registration) {
// NOOP for now
// FIXME: do registration based on only active commit handlers.
}
/**
* Manager responsible for instantiating forwarders responsible for
* forwarding of RPC invocations from DOM Broker to Binding Aware Broker
- *
+ *
*/
private class DomToBindingRpcForwardingManager implements
RouteChangeListener<RpcContextIdentifier, InstanceIdentifier<?>>,
public void setRegistryImpl(RpcProviderRegistryImpl registryImpl) {
this.registryImpl = registryImpl;
}
-
+
@Override
public void onGlobalRpcRegistered(Class<? extends RpcService> cls) {
getRpcForwarder(cls, null);
}
-
+
@Override
public void onGlobalRpcUnregistered(Class<? extends RpcService> cls) {
// NOOP
}
-
+
@Override
public void onRpcRouterCreated(RpcRouter<?> router) {
Class<? extends BaseIdentity> ctx = router.getContexts().iterator().next();
/**
* Constructor for Routed RPC Forwareder.
- *
+ *
* @param service
* @param context
*/
}
}
-
+
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if(EQUALS_METHOD.equals(method)) {
Class<?> cls = rpcServiceType.get();
ClassLoader clsLoader = cls.getClassLoader();
RpcService proxy = (RpcService) Proxy.newProxyInstance(clsLoader, new Class<?>[] { cls }, this);
-
+
RpcRouter rpcRouter = baRpcRegistryImpl.getRpcRouter(rpcServiceType.get());
rpcRouter.registerDefaultService(proxy);
}
RpcResult<?> bindingResult = result.get();
return Rpcs.getRpcResult(true);
}
-
+
@Override
public Future<RpcResult<?>> forwardToDomBroker(DataObject input) {
- if(biRouter != null) {
+ if(biRouter != null) {
CompositeNode xml = mappingService.toDataDom(input);
CompositeNode wrappedXml = ImmutableCompositeNode.create(rpc,ImmutableList.<Node<?>>of(xml));
RpcResult<CompositeNode> result = biRouter.invokeRpc(rpc, wrappedXml);
RpcResult<Void> bindingResult = result.get();
return Rpcs.getRpcResult(bindingResult.isSuccessful(), bindingResult.getErrors());
}
-
+
@Override
public Future<RpcResult<?>> forwardToDomBroker(DataObject input) {
return Futures.immediateFuture(null);
+++ /dev/null
-package org.opendaylight.controller.sal.binding.impl.connect.dom;
-
-import java.util.Map.Entry;
-import java.util.Set;
-
-import org.opendaylight.yangtools.yang.binding.DataContainer;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.RpcService;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-
-public interface BindingIndependentMappingService {
-
- CompositeNode toDataDom(DataObject data);
-
- Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> toDataDom(
- Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry);
-
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toDataDom(InstanceIdentifier<? extends DataObject> path);
-
- DataObject dataObjectFromDataDom(InstanceIdentifier<? extends DataObject> path, CompositeNode result) throws DeserializationException;
-
- InstanceIdentifier<?> fromDataDom(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier entry) throws DeserializationException;
-
- Set<QName> getRpcQNamesFor(Class<? extends RpcService> service);
-
- DataContainer dataObjectFromDataDom(Class<? extends DataContainer> inputClass, CompositeNode domInput);
-
-}
import org.opendaylight.controller.sal.binding.api.mount.MountProviderInstance;
import org.opendaylight.controller.sal.binding.api.mount.MountProviderService;
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
+import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
import org.opendaylight.controller.sal.core.api.mount.MountProvisionInstance;
import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
import org.opendaylight.controller.sal.core.api.mount.MountProvisionService.MountProvisionListener;
private MountProvisionService domMountService;
private MountProviderService baMountService;
private BindingIndependentMappingService mappingService;
-
+
private final DomMountPointForwardingManager domForwardingManager = new DomMountPointForwardingManager();
private final BindingMountPointForwardingManager bindingForwardingManager = new BindingMountPointForwardingManager();
private BindingIndependentConnector createForwarder(InstanceIdentifier<?> path, MountProviderInstance baMountPoint,
MountProvisionInstance domMountPoint) {
BindingIndependentConnector connector = new BindingIndependentConnector();
-
+
connector.setBindingDataService(baMountPoint);
connector.setBindingRpcRegistry(baMountPoint);
//connector.setBindingNotificationBroker(baMountPoint);
-
+
connector.setDomDataService(domMountPoint);
connector.setDomRpcRegistry(domMountPoint);
//connector.setDomNotificationBroker(domMountPoint);
}
tryToDeployConnector(baPath,domPath);
} catch (DeserializationException e) {
-
+
}
}
+++ /dev/null
-package org.opendaylight.controller.sal.binding.impl.connect.dom;
-
-public class DeserializationException extends Exception {
-
- public DeserializationException() {
- }
-
- public DeserializationException(String message) {
- super(message);
- }
-
- public DeserializationException(Throwable cause) {
- super(cause);
- }
-
- public DeserializationException(String message, Throwable cause) {
- super(message, cause);
- }
-
- public DeserializationException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
- super(message, cause, enableSuppression, writableStackTrace);
- }
-
-}
import org.opendaylight.controller.sal.binding.impl.RootBindingAwareBroker;
import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingDomConnectorDeployer;
import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentConnector;
-import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentMappingService;
-import org.opendaylight.controller.sal.binding.impl.connect.dom.DeserializationException;
+import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
import org.opendaylight.controller.sal.core.api.Broker.ProviderSession;
import org.opendaylight.controller.sal.core.api.mount.MountProvisionInstance;
import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
private ProviderSession domProviderContext;
private BindingIndependentConnector connector;
-
+
private MountProvisionService domMountService;
private final DomMountPointForwardingManager domForwardingManager = new DomMountPointForwardingManager();
+++ /dev/null
-package org.opendaylight.controller.sal.binding.impl.util;
-
-import java.util.concurrent.Callable;
-import java.util.concurrent.locks.Lock;
-
-import static com.google.common.base.Preconditions.*;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.Arrays;
-import java.util.List;
-
-import com.google.common.base.Joiner;
-import com.google.common.base.Optional;
-
-public final class ClassLoaderUtils {
-
- private ClassLoaderUtils() {
- throw new UnsupportedOperationException("Utility class");
- }
-
- public static <V> V withClassLoader(ClassLoader cls, Callable<V> function) throws Exception {
- return withClassLoaderAndLock(cls, Optional.<Lock> absent(), function);
- }
-
- public static <V> V withClassLoaderAndLock(ClassLoader cls, Lock lock, Callable<V> function) throws Exception {
- checkNotNull(lock, "Lock should not be null");
- return withClassLoaderAndLock(cls, Optional.of(lock), function);
- }
-
- public static <V> V withClassLoaderAndLock(ClassLoader cls, Optional<Lock> lock, Callable<V> function)
- throws Exception {
- checkNotNull(cls, "Classloader should not be null");
- checkNotNull(function, "Function should not be null");
- if (lock.isPresent()) {
- lock.get().lock();
- }
- ClassLoader oldCls = Thread.currentThread().getContextClassLoader();
- try {
- Thread.currentThread().setContextClassLoader(cls);
- return function.call();
- } finally {
- Thread.currentThread().setContextClassLoader(oldCls);
- if (lock.isPresent()) {
- lock.get().unlock();
- }
- }
- }
-
- public static Object construct(Constructor<? extends Object> constructor, List<Object> objects)
- throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
- Object[] initargs = objects.toArray(new Object[] {});
- return constructor.newInstance(initargs);
- }
-
- public static Class<?> loadClassWithTCCL(String name) throws ClassNotFoundException {
- if ("byte[]".equals(name)) {
- return byte[].class;
- } else if("char[]".equals(name)) {
- return char[].class;
- }
- try {
- return Thread.currentThread().getContextClassLoader().loadClass(name);
- } catch (ClassNotFoundException e) {
- String[] components = name.split("\\.");
- String potentialOuter;
- int length = components.length;
- if (length > 2 && (potentialOuter = components[length - 2]) != null && Character.isUpperCase(potentialOuter.charAt(0))) {
-
- String outerName = Joiner.on(".").join(Arrays.asList(components).subList(0, length - 1));
- String innerName = outerName + "$" + components[length-1];
- return Thread.currentThread().getContextClassLoader().loadClass(innerName);
- } else {
- throw e;
- }
- }
- }
-
- public static Class<?> tryToLoadClassWithTCCL(String fullyQualifiedName) {
- try {
- return loadClassWithTCCL(fullyQualifiedName);
- } catch (ClassNotFoundException e) {
- return null;
- }
- }
-}
\ No newline at end of file
+++ /dev/null
-package org.opendaylight.controller.sal.binding.impl.util;
-
-import java.util.List;
-
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-
-import com.google.common.base.Preconditions;
-
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-
-public class YangSchemaUtils {
-
- public static final String AUGMENT_IDENTIFIER = "augment-identifier";
-
-
- public YangSchemaUtils() {
- throw new UnsupportedOperationException("Helper class. Instantiation is prohibited");
- }
-
-
- public static QName getAugmentationQName(AugmentationSchema augmentation) {
- Preconditions.checkNotNull(augmentation, "Augmentation must not be null.");
- QName identifier = getAugmentationIdentifier(augmentation);
- if(identifier != null) {
- return identifier;
- }
- for(DataSchemaNode child : augmentation.getChildNodes()) {
- // FIXME: Return true name
- return QName.create(child.getQName(), "foo_augment");
- }
- // FIXME: Allways return a qname with module namespace.
- return null;
- }
-
- public static QName getAugmentationIdentifier(AugmentationSchema augmentation) {
- for(UnknownSchemaNode extension : augmentation.getUnknownSchemaNodes()) {
- if(AUGMENT_IDENTIFIER.equals(extension.getNodeType().getLocalName())) {
- return extension.getQName();
- }
- }
- return null;
- }
-
-
- public static TypeDefinition<?> findTypeDefinition(SchemaContext context, SchemaPath path) {
- List<QName> arguments = path.getPath();
- QName first = arguments.get(0);
- QName typeQName = arguments.get(arguments.size() -1);
- DataNodeContainer previous = context.findModuleByNamespaceAndRevision(first.getNamespace(), first.getRevision());
- if(previous == null) {
- return null;
- }
- Preconditions.checkArgument(arguments.size() == 1);
- for (QName qName : arguments) {
- //previous.getDataChildByName(qName);
- }
- for(TypeDefinition<?> typedef : previous.getTypeDefinitions()) {
- if(typedef.getQName().equals(typeQName)) {
- return typedef;
- }
- }
- return null;
- }
-}
--- /dev/null
+package org.opendaylight.controller.sal.binding.osgi;
+
+import org.opendaylight.controller.sal.binding.codegen.impl.SingletonHolder;
+import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl;
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
+import org.osgi.framework.BundleActivator;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceRegistration;
+
+import java.util.Hashtable;
+
+public class Activator implements BundleActivator {
+
+ private ServiceRegistration<?> reg;
+ private ServiceRegistration<SchemaServiceListener> listenerReg;
+ private ServiceRegistration<BindingIndependentMappingService> mappingReg;
+
+ @Override
+ public void start(BundleContext context) throws Exception {
+ RuntimeGeneratedMappingServiceImpl service = new RuntimeGeneratedMappingServiceImpl();
+ service.setPool(SingletonHolder.CLASS_POOL);
+ service.init();
+ startRuntimeMappingService(service, context);
+ }
+
+ private void startRuntimeMappingService(RuntimeGeneratedMappingServiceImpl service, BundleContext context) {
+ Hashtable<String, String> properties = new Hashtable<String, String>();
+ listenerReg = context.registerService(SchemaServiceListener.class, service, properties);
+ mappingReg = context.registerService(BindingIndependentMappingService.class, service, properties);
+
+ }
+
+ @Override
+ public void stop(BundleContext context) throws Exception {
+ if(listenerReg != null) {
+ listenerReg.unregister();
+ }
+ if(mappingReg != null) {
+ mappingReg.unregister();
+ }
+ }
+}
identity binding-dom-mapping-service {
base config:service-type;
- config:java-class "org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentMappingService";
+ config:java-class "org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService";
}
package org.opendaylight.controller.sal.binding.test;
-import java.io.File;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-import javassist.ClassPool;
-
import org.junit.After;
import org.junit.Before;
import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
-import org.opendaylight.controller.sal.binding.impl.DataBrokerImpl;
-import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentConnector;
-import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentMappingService;
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
import org.opendaylight.controller.sal.binding.test.util.BindingBrokerTestFactory;
import org.opendaylight.controller.sal.binding.test.util.BindingTestContext;
-import org.opendaylight.controller.sal.binding.dom.serializer.impl.RuntimeGeneratedMappingServiceImpl;
-import org.opendaylight.controller.sal.core.api.data.DataBrokerService;
import org.opendaylight.controller.sal.core.api.data.DataStore;
import org.opendaylight.controller.sal.dom.broker.impl.DataStoreStatsWrapper;
import org.opendaylight.controller.sal.dom.broker.impl.HashMapDataStore;
-import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareDataStoreAdapter;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
-import org.reflections.Reflections;
-import org.reflections.scanners.ResourcesScanner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Predicate;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
factory.setStartWithParsedSchema(getStartWithSchema());
testContext = factory.getTestContext();
testContext.start();
-
+
baDataService = testContext.getBindingDataBroker();
biDataService = testContext.getDomDataBroker();
dataStore = testContext.getDomDataStore();
import javassist.ClassPool;
-import org.eclipse.xtext.xbase.lib.Pure;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
import org.opendaylight.controller.sal.binding.api.mount.MountProviderService;
-import org.opendaylight.controller.sal.binding.dom.serializer.impl.RuntimeGeneratedMappingServiceImpl;
import org.opendaylight.controller.sal.binding.impl.DataBrokerImpl;
import org.opendaylight.controller.sal.binding.impl.NotificationBrokerImpl;
-import org.opendaylight.controller.sal.binding.impl.RootBindingAwareBroker;
import org.opendaylight.controller.sal.binding.impl.RpcProviderRegistryImpl;
import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingDomConnectorDeployer;
import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentConnector;
-import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentMappingService;
import org.opendaylight.controller.sal.binding.impl.forward.DomForwardedBindingBrokerImpl;
-import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest;
import org.opendaylight.controller.sal.core.api.Broker.ProviderSession;
import org.opendaylight.controller.sal.core.api.Broker.RoutedRpcRegistration;
import org.opendaylight.controller.sal.core.api.Broker.RpcRegistration;
import org.opendaylight.controller.sal.core.api.RpcRegistrationListener;
import org.opendaylight.controller.sal.core.api.data.DataStore;
import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
-import org.opendaylight.controller.sal.core.api.notify.NotificationPublishService;
import org.opendaylight.controller.sal.dom.broker.BrokerImpl;
import org.opendaylight.controller.sal.dom.broker.MountPointManagerImpl;
import org.opendaylight.controller.sal.dom.broker.impl.DataStoreStatsWrapper;
import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareRpcBroker;
import org.opendaylight.controller.sal.dom.broker.impl.SchemaContextProvider;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
import static com.google.common.base.Preconditions.*;
checkState(classPool != null, "ClassPool needs to be present");
mappingServiceImpl = new RuntimeGeneratedMappingServiceImpl();
mappingServiceImpl.setPool(classPool);
- mappingServiceImpl.start(null);
+ mappingServiceImpl.init();
}
public void updateYangSchema(String[] files) {
</goals>
<configuration>
<codeGenerators>
+ <generator>
+ <codeGeneratorClass>
+ org.opendaylight.yangtools.maven.sal.api.gen.plugin.CodeGeneratorImpl
+ </codeGeneratorClass>
+ <outputBaseDir>
+ target/generated-sources/sal
+ </outputBaseDir>
+ </generator>
<generator>
<codeGeneratorClass>
org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
@Override
public Void call() {
try {
- //startSyncObject.wait();
+ //startSyncObj ect.wait();
//Thread.sleep(500);
createFlow();
createFlow2();
</execution>
</executions>
</plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <version>2.14.1</version>
+ <configuration>
+ <reuseForks>false</reuseForks>
+ </configuration>
+ </plugin>
</plugins>
<pluginManagement>
<plugins>
public static Option configMinumumBundles() {
return new DefaultCompositeOption(
+ mavenBundle(CONTROLLER, "config-api").versionAsInProject(), // //
+ bindingAwareSalBundles(),
mavenBundle("commons-codec", "commons-codec").versionAsInProject(),
- mavenBundle(CONTROLLER, "config-api").versionAsInProject(), // //
mavenBundle(CONTROLLER, "protocol-framework").versionAsInProject(), //
mavenBundle(CONTROLLER, "config-manager").versionAsInProject(), // //
mavenBundle("commons-io", "commons-io").versionAsInProject(), //
- mavenBundle(CONTROLLER, "config-api").versionAsInProject(), //
mavenBundle(CONTROLLER, "config-manager").versionAsInProject(), //
mavenBundle(CONTROLLER, "yang-jmx-generator").versionAsInProject(), //
mavenBundle(CONTROLLER, "yang-store-api").versionAsInProject(), //
public static Option bindingAwareSalBundles() {
return new DefaultCompositeOption( //
- mavenBundle(CONTROLLER, "sal-binding-api").versionAsInProject(), // //
- mavenBundle(CONTROLLER, "sal-binding-config").versionAsInProject(), //
- mavenBundle(CONTROLLER, "sal-binding-broker-impl").versionAsInProject(), // //
- mavenBundle(CONTROLLER, "sal-binding-util").versionAsInProject(), //
+ mdSalCoreBundles(),
+
mavenBundle("org.javassist", "javassist").versionAsInProject(), // //
- mavenBundle(CONTROLLER, "sal-common-util").versionAsInProject(), // //
-
+
mavenBundle(YANGTOOLS, "yang-data-api").versionAsInProject(), // //
mavenBundle(YANGTOOLS, "yang-data-impl").versionAsInProject(), // //
mavenBundle(YANGTOOLS, "yang-model-api").versionAsInProject(), // //
mavenBundle(YANGTOOLS, "yang-model-util").versionAsInProject(), // //
mavenBundle(YANGTOOLS, "yang-parser-api").versionAsInProject(), //
mavenBundle(YANGTOOLS, "yang-parser-impl").versionAsInProject(),
-
mavenBundle(YANGTOOLS, "binding-generator-spi").versionAsInProject(), // //
mavenBundle(YANGTOOLS, "binding-model-api").versionAsInProject(), // //
mavenBundle(YANGTOOLS, "binding-generator-util").versionAsInProject(), //
mavenBundle(YANGTOOLS, "binding-generator-api").versionAsInProject(), mavenBundle(YANGTOOLS,
"binding-generator-spi").versionAsInProject(), //
mavenBundle(YANGTOOLS, "binding-generator-impl").versionAsInProject(),
-
+ mavenBundle(YANGTOOLS + ".thirdparty", "antlr4-runtime-osgi-nohead").versionAsInProject(), // //
+
mavenBundle(CONTROLLER, "sal-core-api").versionAsInProject().update(), //
+ mavenBundle(CONTROLLER, "sal-binding-api").versionAsInProject(), // //
+ mavenBundle(CONTROLLER, "sal-binding-config").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "sal-binding-broker-impl").versionAsInProject(), // //
+ mavenBundle(CONTROLLER, "sal-binding-util").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "sal-common-util").versionAsInProject(), // //
+
+
+
mavenBundle(CONTROLLER, "sal-broker-impl").versionAsInProject(), // //
mavenBundle(CONTROLLER, "sal-core-spi").versionAsInProject().update(), //
- mavenBundle(YANGTOOLS + ".thirdparty", "antlr4-runtime-osgi-nohead").versionAsInProject(), // //
systemProperty("netconf.tcp.address").value("0.0.0.0"), //
systemProperty("netconf.tcp.port").value("18383"), //
public Option[] config() {
return options(systemProperty("osgi.console").value("2401"), mavenBundle("org.slf4j", "slf4j-api")
.versionAsInProject(), //
- systemProperty("logback.configurationFile").value(
- "file:" + PathUtils.getBaseDir()
- + "/src/test/resources/logback.xml"),
+// systemProperty("logback.configurationFile").value(
+// "file:" + PathUtils.getBaseDir()
+// + "/src/test/resources/logback.xml"),
mavenBundle("org.slf4j", "log4j-over-slf4j").versionAsInProject(), //
mavenBundle("ch.qos.logback", "logback-core").versionAsInProject(), //
mavenBundle("ch.qos.logback", "logback-classic").versionAsInProject(), //
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
public interface SchemaService extends BrokerService {
/**
- * Registers a YANG module to session and global context
- *
+ * Registers a YANG module to session and global context
+ *
* @param module
*/
void addModule(Module module);
-
+
/**
* Unregisters a YANG module from session context
- *
+ *
* @param module
*/
void removeModule(Module module);
-
+
/**
* Returns session specific YANG schema context
* @return
*/
SchemaContext getSessionContext();
-
+
/**
* Returns global schema context
- *
+ *
* @return
*/
SchemaContext getGlobalContext();
-
+
ListenerRegistration<SchemaServiceListener> registerSchemaServiceListener(SchemaServiceListener listener);
}
+++ /dev/null
-package org.opendaylight.controller.sal.core.api.model;
-
-import java.util.EventListener;
-
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-
-public interface SchemaServiceListener extends EventListener {
-
-
- void onGlobalContextUpdated(SchemaContext context);
-
-}
<configuration>
<instructions>
<Bundle-Name>${project.groupId}.${project.artifactId}</Bundle-Name>
+ <Bundle-Activator>org.opendaylight.controller.sal.dom.broker.osgi.SchemaServiceActivator</Bundle-Activator>
<Export-Package>
org.opendaylight.controller.sal.dom.broker.spi
</Export-Package>
org.opendaylight.controller.sal.dom.broker,
org.opendaylight.controller.sal.dom.broker.impl,
org.opendaylight.controller.sal.dom.broker.osgi,
+ org.opendaylight.controller.sal.dom.broker.util,
org.opendaylight.controller.config.yang.md.sal.dom.impl,
org.opendaylight.controller.config.yang.md.sal.dom.statistics,
org.opendaylight.yangtools.yang.util
/**
-* Generated file
+ * Generated file
-* Generated from: yang module name: opendaylight-sal-dom-broker-impl yang module local name: schema-service-singleton
-* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
-* Generated at: Wed Nov 20 17:01:31 CET 2013
-*
-* Do not modify this file unless it is present under src/main directory
-*/
+ * Generated from: yang module name: opendaylight-sal-dom-broker-impl yang module local name: schema-service-singleton
+ * Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+ * Generated at: Wed Nov 20 17:01:31 CET 2013
+ *
+ * Do not modify this file unless it is present under src/main directory
+ */
package org.opendaylight.controller.config.yang.md.sal.dom.impl;
-import org.opendaylight.controller.sal.dom.broker.SchemaServiceImpl;
-import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
+import org.opendaylight.controller.sal.core.api.model.SchemaService;
+import org.opendaylight.controller.sal.dom.broker.GlobalBundleScanningSchemaServiceImpl;
+import org.opendaylight.yangtools.concepts.Delegator;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
/**
*
*/
-public final class SchemaServiceImplSingletonModule extends org.opendaylight.controller.config.yang.md.sal.dom.impl.AbstractSchemaServiceImplSingletonModule
-{
+public final class SchemaServiceImplSingletonModule extends
+ org.opendaylight.controller.config.yang.md.sal.dom.impl.AbstractSchemaServiceImplSingletonModule {
BundleContext bundleContext;
-
- public SchemaServiceImplSingletonModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+
+ public SchemaServiceImplSingletonModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier,
+ org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
super(identifier, dependencyResolver);
}
- public SchemaServiceImplSingletonModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, SchemaServiceImplSingletonModule oldModule, java.lang.AutoCloseable oldInstance) {
+ public SchemaServiceImplSingletonModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier,
+ org.opendaylight.controller.config.api.DependencyResolver dependencyResolver,
+ SchemaServiceImplSingletonModule oldModule, java.lang.AutoCloseable oldInstance) {
super(identifier, dependencyResolver, oldModule, oldInstance);
}
-
+
@Override
public boolean canReuseInstance(AbstractSchemaServiceImplSingletonModule oldModule) {
return true;
}
@Override
- public void validate(){
+ public void validate() {
super.validate();
}
@Override
public java.lang.AutoCloseable createInstance() {
- SchemaServiceImpl newInstance = new SchemaServiceImpl();
+ ServiceReference<SchemaService> ref = getBundleContext().getServiceReference(SchemaService.class);
+ if (ref != null) {
+ return new GlobalSchemaServiceProxy(getBundleContext(), ref);
+ }
+
+ GlobalBundleScanningSchemaServiceImpl newInstance = new GlobalBundleScanningSchemaServiceImpl();
newInstance.setContext(getBundleContext());
newInstance.start();
return newInstance;
}
+
+ public class GlobalSchemaServiceProxy implements AutoCloseable, SchemaService, Delegator<SchemaService> {
+
+ private BundleContext bundleContext;
+ private ServiceReference<SchemaService> reference;
+ private SchemaService delegate;
+
+ public GlobalSchemaServiceProxy(BundleContext bundleContext, ServiceReference<SchemaService> ref) {
+ this.bundleContext = bundleContext;
+ this.reference = ref;
+ this.delegate = bundleContext.getService(reference);
+ }
+
+ @Override
+ public void close() throws Exception {
+ if (delegate != null) {
+ delegate = null;
+ bundleContext.ungetService(reference);
+ reference = null;
+ bundleContext = null;
+ }
+ }
+
+ public void addModule(Module arg0) {
+ delegate.addModule(arg0);
+ }
+
+ public SchemaContext getGlobalContext() {
+ return delegate.getGlobalContext();
+ }
+
+ public SchemaContext getSessionContext() {
+ return delegate.getSessionContext();
+ }
+
+ public ListenerRegistration<SchemaServiceListener> registerSchemaServiceListener(SchemaServiceListener arg0) {
+ return delegate.registerSchemaServiceListener(arg0);
+ }
+
+ public void removeModule(Module arg0) {
+ delegate.removeModule(arg0);
+ }
+
+ @Override
+ public SchemaService getDelegate() {
+ return delegate;
+ }
+
+ }
}
import org.opendaylight.controller.sal.core.api.data.DataProviderService
import org.opendaylight.controller.sal.core.api.data.DataStore
import org.opendaylight.controller.sal.core.api.model.SchemaService
-import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener
import org.opendaylight.controller.sal.core.api.mount.MountProvisionService
import org.opendaylight.controller.sal.core.api.mount.MountService
import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareDataStoreAdapter
import java.util.Enumeration;
import org.opendaylight.controller.sal.core.api.model.SchemaService;
-import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener;
import org.opendaylight.controller.sal.dom.broker.impl.SchemaContextProvider;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.concepts.util.ListenerRegistry;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
import org.opendaylight.yangtools.yang.parser.impl.util.URLSchemaContextResolver;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
-public class SchemaServiceImpl implements //
+public class GlobalBundleScanningSchemaServiceImpl implements //
SchemaContextProvider, //
SchemaService, //
ServiceTrackerCustomizer<SchemaServiceListener, SchemaServiceListener>, //
AutoCloseable {
- private static final Logger logger = LoggerFactory.getLogger(SchemaServiceImpl.class);
+ private static final Logger logger = LoggerFactory.getLogger(GlobalBundleScanningSchemaServiceImpl.class);
private ListenerRegistry<SchemaServiceListener> listeners;
-
+
private BundleContext context;
private BundleScanner scanner = new BundleScanner();
listeners = new ListenerRegistry<>();
}
- listenerTracker = new ServiceTracker<>(context, SchemaServiceListener.class, SchemaServiceImpl.this);
+ listenerTracker = new ServiceTracker<>(context, SchemaServiceListener.class, GlobalBundleScanningSchemaServiceImpl.this);
bundleTracker = new BundleTracker<ImmutableSet<Registration<URL>>>(context, BundleEvent.RESOLVED
| BundleEvent.UNRESOLVED, scanner);
bundleTracker.open();
SchemaServiceListener listener = context.getService(reference);
SchemaContext _ctxContext = getGlobalContext();
- if (_ctxContext != null) {
+ if (getContext() != null && _ctxContext != null) {
listener.onGlobalContextUpdated(_ctxContext);
}
return listener;
package org.opendaylight.controller.sal.dom.broker.impl;
-import java.awt.PageAttributes.OriginType;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.Comparator;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
import java.util.Map.Entry;
-import java.util.Set;
import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicLong;
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.DataModification;
import org.opendaylight.controller.md.sal.common.impl.AbstractDataModification;
import org.opendaylight.controller.md.sal.common.impl.util.AbstractLockableDelegator;
import org.opendaylight.controller.sal.core.api.data.DataStore;
-import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener;
+import org.opendaylight.controller.sal.dom.broker.util.YangSchemaUtils;
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.util.YangDataOperations;
-import org.opendaylight.yangtools.yang.util.YangSchemaUtils;
+import org.opendaylight.controller.sal.dom.broker.util.YangDataOperations;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.collect.FluentIterable;
import static com.google.common.base.Preconditions.*;
-import org.opendaylight.yangtools.yang.util.YangDataOperations;
public class SchemaAwareDataStoreAdapter extends AbstractLockableDelegator<DataStore> implements //
DataStore, //
@Override
protected CompositeNode mergeOperationalData(InstanceIdentifier path, CompositeNode stored,
CompositeNode modified) {
- // TODO Auto-generated method stub
return mergeData(path, stored, modified, false);
}
}
--- /dev/null
+package org.opendaylight.controller.sal.dom.broker.osgi;
+
+import java.util.Hashtable;
+
+import org.opendaylight.controller.sal.core.api.model.SchemaService;
+import org.opendaylight.controller.sal.dom.broker.GlobalBundleScanningSchemaServiceImpl;
+import org.osgi.framework.BundleActivator;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceRegistration;
+
+public class SchemaServiceActivator implements BundleActivator {
+
+
+ private ServiceRegistration<SchemaService> schemaServiceReg;
+ private GlobalBundleScanningSchemaServiceImpl schemaService;
+
+ @Override
+ public void start(BundleContext context) throws Exception {
+ schemaService = new GlobalBundleScanningSchemaServiceImpl();
+ schemaService.setContext(context);
+ schemaService.start();
+ schemaServiceReg = context.registerService(SchemaService.class, schemaService, new Hashtable<String,String>());
+ }
+
+ @Override
+ public void stop(BundleContext context) throws Exception {
+ schemaServiceReg.unregister();
+ schemaService.close();
+ }
+}
package org.opendaylight.controller.sal.dom.broker.osgi;
import org.opendaylight.controller.sal.core.api.model.SchemaService;
-import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener;
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
return registration;
}
-
-
+
+
}
-package org.opendaylight.yangtools.yang.util
+package org.opendaylight.controller.sal.dom.broker.util
import org.opendaylight.yangtools.yang.data.api.CompositeNode
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode
import java.util.Collections
-import static extension org.opendaylight.yangtools.yang.util.YangDataUtils.*;
import java.util.HashSet
import org.opendaylight.yangtools.yang.common.QName
+import static extension org.opendaylight.controller.sal.dom.broker.util.YangDataUtils.*;
class YangDataOperations {
static def CompositeNode merge(DataSchemaNode schema, CompositeNode stored, CompositeNode modified, boolean config) {
- checkConfigurational(schema, config);
if (stored === null) {
return modified;
}
List<Node<?>> modified, boolean configurational) {
checkArgument(original.size === 1);
checkArgument(modified.size === 1);
- checkConfigurational(node, configurational);
+
return modified;
}
private static dispatch def Iterable<? extends Node<?>> mergeMultiple(ListSchemaNode node, List<Node<?>> original,
List<Node<?>> modified, boolean configurational) {
- checkConfigurational(node,configurational);
+
if(node.keyDefinition === null || node.keyDefinition.empty) {
return modified;
}
-package org.opendaylight.yangtools.yang.util;
+package org.opendaylight.controller.sal.dom.broker.util;
import java.util.HashMap;
import java.util.List;
-package org.opendaylight.yangtools.yang.util;
+package org.opendaylight.controller.sal.dom.broker.util;
import java.util.Iterator;
import com.fasterxml.jackson.core.JsonParseException;
import org.junit.Assert;
import org.junit.Test;
+import org.opendaylight.controller.sal.connector.api.RpcRouter;
import org.opendaylight.controller.sal.connector.remoterpc.dto.RouteIdentifierImpl;
import org.opendaylight.yangtools.yang.common.QName;
import org.slf4j.Logger;
RouteIdentifierImpl rId = new RouteIdentifierImpl();
rId.setType(QNAME);
- _logger.debug("route: " + rId.fromString(rId.toString()));
+ String s = rId.toString();
+ _logger.debug("serialized route: {}", s);
+
+ RpcRouter.RouteIdentifier ref = new RouteIdentifierImpl().fromString(s);
+ _logger.debug("deserialized route: {}", ref);
Assert.assertTrue(true);
}
import org.opendaylight.controller.sal.core.api.Provider;
import org.opendaylight.controller.sal.core.api.data.DataBrokerService;
import org.opendaylight.controller.sal.core.api.model.SchemaService;
-import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener;
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
import org.opendaylight.controller.sal.core.api.mount.MountService;
import org.opendaylight.controller.sal.restconf.impl.BrokerFacade;
import org.opendaylight.controller.sal.restconf.impl.ControllerContext;
public class RestconfProvider implements BundleActivator, Provider, ServiceTrackerCustomizer<Broker, Broker> {
public final static String NOT_INITALIZED_MSG = "Restconf is not initialized yet. Please try again later";
-
+
private ListenerRegistration<SchemaServiceListener> listenerRegistration;
private ServiceTracker<Broker, Broker> brokerServiceTrancker;
private BundleContext bundleContext;
import java.util.List
import java.util.Map
import java.util.concurrent.ConcurrentHashMap
-import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener
+import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener
import org.opendaylight.controller.sal.core.api.mount.MountService
import org.opendaylight.controller.sal.rest.impl.RestUtil
import org.opendaylight.controller.sal.rest.impl.RestconfProvider
@Property
var SchemaContext globalSchema;
-
+
@Property
var MountService mountService;
val modules = schema.modules.filter[m|m.name == moduleName]
return modules.filterLatestModule
}
-
+
private def filterLatestModule(Iterable<Module> modules) {
var latestModule = modules.head
for (module : modules) {
}
return latestModule
}
-
+
def findModuleByName(String moduleName) {
checkPreconditions
checkArgument(moduleName !== null && !moduleName.empty)
return globalSchema.getLatestModule(moduleName)
}
-
+
def findModuleByName(MountInstance mountPoint, String moduleName) {
checkArgument(moduleName !== null && mountPoint !== null)
val mountPointSchema = mountPoint.schemaContext;
return mountPointSchema?.getLatestModule(moduleName);
}
-
+
def findModuleByNamespace(URI namespace) {
checkPreconditions
checkArgument(namespace !== null)
val moduleSchemas = globalSchema.findModuleByNamespace(namespace)
return moduleSchemas?.filterLatestModule
}
-
+
def findModuleByNamespace(MountInstance mountPoint, URI namespace) {
checkArgument(namespace !== null && mountPoint !== null)
val mountPointSchema = mountPoint.schemaContext;
}
return moduleName
}
-
+
def findModuleNameByNamespace(MountInstance mountPoint, URI namespace) {
val module = mountPoint.findModuleByNamespace(namespace);
return module?.name
}
return namespace
}
-
+
def findNamespaceByModuleName(MountInstance mountPoint, String moduleName) {
val module = mountPoint.findModuleByName(moduleName)
return module?.namespace
if(object === null) return "";
return URLEncoder.encode(object.toString)
}
-
+
private def InstanceIdWithSchemaNode collectPathArguments(InstanceIdentifierBuilder builder, List<String> strings,
DataNodeContainer parentNode, MountInstance mountPoint) {
checkNotNull(strings)
if (strings.empty) {
return new InstanceIdWithSchemaNode(builder.toInstance, parentNode as DataSchemaNode, mountPoint)
}
-
+
val nodeName = strings.head.toNodeName
val moduleName = strings.head.toModuleName
var DataSchemaNode targetNode = null
if (mountPoint !== null) {
throw new ResponseException(BAD_REQUEST, "Restconf supports just one mount point in URI.")
}
-
+
if (mountService === null) {
- throw new ResponseException(SERVICE_UNAVAILABLE, "MountService was not found. "
+ throw new ResponseException(SERVICE_UNAVAILABLE, "MountService was not found. "
+ "Finding behind mount points does not work."
)
}
-
+
val partialPath = builder.toInstance;
val mount = mountService.getMountPoint(partialPath)
if (mount === null) {
LOG.debug("Instance identifier to missing mount point: {}", partialPath)
throw new ResponseException(BAD_REQUEST, "Mount point does not exist.")
}
-
+
val mountPointSchema = mount.schemaContext;
if (mountPointSchema === null) {
throw new ResponseException(BAD_REQUEST, "Mount point does not contain any schema with modules.")
}
-
+
if (strings.size == 1) { // any data node is not behind mount point
return new InstanceIdWithSchemaNode(InstanceIdentifier.builder().toInstance, mountPointSchema, mount)
}
-
+
val moduleNameBehindMountPoint = strings.get(1).toModuleName()
if (moduleNameBehindMountPoint === null) {
throw new ResponseException(BAD_REQUEST,
"First node after mount point in URI has to be in format \"moduleName:nodeName\"")
}
-
+
val moduleBehindMountPoint = mountPointSchema.getLatestModule(moduleNameBehindMountPoint)
if (moduleBehindMountPoint === null) {
throw new ResponseException(BAD_REQUEST,
"URI has bad format. \"" + moduleName + "\" module does not exist in mount point.")
}
-
+
return collectPathArguments(InstanceIdentifier.builder(), strings.subList(1, strings.size),
moduleBehindMountPoint, mount);
}
-
+
var Module module = null;
if (mountPoint === null) {
module = globalSchema.getLatestModule(moduleName)
}
targetNode = parentNode.findInstanceDataChild(nodeName, module.namespace)
if (targetNode === null) {
- throw new ResponseException(BAD_REQUEST, "URI has bad format. Possible reasons:\n" +
- "1. \"" + strings.head + "\" was not found in parent data node.\n" +
+ throw new ResponseException(BAD_REQUEST, "URI has bad format. Possible reasons:\n" +
+ "1. \"" + strings.head + "\" was not found in parent data node.\n" +
"2. \"" + strings.head + "\" is behind mount point. Then it should be in format \"/" + MOUNT + "/" + strings.head + "\".")
}
} else { // string without module name
throw new ResponseException(BAD_REQUEST, "URI has bad format. \"" + nodeName + "\" was not found in parent data node.\n")
}
}
-
+
// Number of consumed elements
var consumed = 1;
if (targetNode instanceof ListSchemaNode) {
// key value cannot be NULL
if (uriKeyValue.equals(NULL_VALUE)) {
- throw new ResponseException(BAD_REQUEST, "URI has bad format. List \"" + listNode.QName.localName
+ throw new ResponseException(BAD_REQUEST, "URI has bad format. List \"" + listNode.QName.localName
+ "\" cannot contain \"null\" value as a key."
)
}
} else {
potentialNode = container.childNodes.filter[n|n.QName.localName == name && n.QName.namespace == moduleNamespace].head
}
-
+
if (potentialNode.instantiatedDataSchema) {
return potentialNode;
}
}
return null;
}
-
+
static def boolean isInstantiatedDataSchema(DataSchemaNode node) {
switch node {
LeafSchemaNode: return true
checkArgument(node instanceof LeafSchemaNode);
val urlDecoded = URLDecoder.decode(uriValue);
val typedef = (node as LeafSchemaNode).type;
-
+
var decoded = TypeDefinitionAwareCodec.from(typedef)?.deserialize(urlDecoded)
if(decoded === null) {
var baseType = RestUtil.resolveBaseTypeFrom(typedef)
}
public void setTxIdAndTableIdMapEntry(NodeId nodeId, TransactionId id,Short tableId){
-
+ if(id == null)
+ return;
txIdTotableIdMap.put(new TxIdEntry(nodeId,id,null), tableId);
}
}
}
public void addTxIdToRequestTypeEntry (NodeId nodeId, TransactionId id,StatsRequestType type){
+ if(id == null)
+ return;
TxIdEntry entry = new TxIdEntry(nodeId,id,type);
txIdToRequestTypeMap.put(entry, getExpiryTime());
}
if(nodes == null)
return null;
- spLogger.info("Number of connected nodes : {}",nodes.getNode().size());
+ spLogger.debug("Number of connected nodes : {}",nodes.getNode().size());
return nodes.getNode();
}
FlowCapableNode node = (FlowCapableNode)dps.readOperationalData(nodesIdentifier);
List<Short> tablesId = new ArrayList<Short>();
if(node != null && node.getTable()!=null){
- spLogger.info("Number of tables {} supported by node {}",node.getTable().size(),nodeKey);
+ spLogger.debug("Number of tables {} supported by node {}",node.getTable().size(),nodeKey);
for(Table table: node.getTable()){
tablesId.add(table.getId());
}
.child(Flow.class,newFlowKey).toInstance();
flowBuilder.setKey(newFlowKey);
flowBuilder.addAugmentation(FlowStatisticsData.class, flowStatisticsData.build());
- sucLogger.info("Flow {} is not present in config data store, augmenting statistics as an unaccounted flow",flowBuilder.build());
+ sucLogger.debug("Flow {} is not present in config data store, augmenting statistics as an unaccounted flow",flowBuilder.build());
it.putOperationalData(flowRef, flowBuilder.build());
it.commit();
}
if (statsFlow.getClass() != storedFlow.getClass()) {
return false;
}
- if (statsFlow.getBufferId()== null) {
- if (storedFlow.getBufferId() != null) {
- return false;
- }
- } else if(!statsFlow.getBufferId().equals(storedFlow.getBufferId())) {
- return false;
- }
if (statsFlow.getContainerName()== null) {
if (storedFlow.getContainerName()!= null) {
return false;
} else if(!statsFlow.getContainerName().equals(storedFlow.getContainerName())) {
return false;
}
- if (statsFlow.getCookie()== null) {
- if (storedFlow.getCookie()!= null) {
- return false;
- }
- } else if(!statsFlow.getCookie().equals(storedFlow.getCookie())) {
- return false;
- }
if (statsFlow.getMatch()== null) {
if (storedFlow.getMatch() != null) {
return false;
else if(!matchEquals(statsFlow.getMatch(), storedFlow.getMatch())) {
return false;
}
- if (statsFlow.getHardTimeout() == null) {
- if (storedFlow.getHardTimeout() != null) {
- return false;
- }
- } else if(!statsFlow.getHardTimeout().equals(storedFlow.getHardTimeout() )) {
- return false;
- }
- if (statsFlow.getIdleTimeout()== null) {
- if (storedFlow.getIdleTimeout() != null) {
- return false;
- }
- } else if(!statsFlow.getIdleTimeout().equals(storedFlow.getIdleTimeout())) {
- return false;
- }
if (statsFlow.getPriority() == null) {
if (storedFlow.getPriority() != null) {
return false;
return caseJavaBinaryAttribute(openType);
} else if(((JavaAttribute)attributeIfc).isUnion()) {
return caseJavaUnionAttribute(openType);
+ } else if(((JavaAttribute)attributeIfc).isIdentityRef()) {
+ return caseJavaIdentityRefAttribute(openType);
} else
return caseJavaAttribute(openType);
} catch (UnknownOpenTypeException e) {
throw getIllegalArgumentException(attributeIfc);
}
+ protected T caseJavaIdentityRefAttribute(OpenType<?> openType) {
+ return caseJavaAttribute(openType);
+ }
+
protected T caseJavaUnionAttribute(OpenType<?> openType) {
return caseJavaAttribute(openType);
}
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListDependenciesAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.AttributeIfcSwitchStatement;
+import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfig;
import javax.management.openmbean.ArrayType;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenType;
import javax.management.openmbean.SimpleType;
+import java.util.Date;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Set;
public class ObjectXmlReader extends AttributeIfcSwitchStatement<AttributeReadingStrategy> {
private String key;
+ private Map<String, Map<Date, EditConfig.IdentityMapping>> identityMap;
- public Map<String, AttributeReadingStrategy> prepareReading(Map<String, AttributeIfc> yangToAttrConfig) {
+ public Map<String, AttributeReadingStrategy> prepareReading(Map<String, AttributeIfc> yangToAttrConfig, Map<String, Map<Date,EditConfig.IdentityMapping>> identityMap) {
Map<String, AttributeReadingStrategy> strategies = Maps.newHashMap();
+ this.identityMap = identityMap;
for (Entry<String, AttributeIfc> attributeEntry : yangToAttrConfig.entrySet()) {
AttributeReadingStrategy strat = prepareReadingStrategy(attributeEntry.getKey(), attributeEntry.getValue());
return new SimpleCompositeAttributeReadingStrategy(lastAttribute.getNullableDefault(), mappingKey);
}
+ @Override
+ protected AttributeReadingStrategy caseJavaIdentityRefAttribute(OpenType<?> openType) {
+ Preconditions.checkState(openType instanceof CompositeType);
+ Set<String> keys = ((CompositeType) openType).keySet();
+ Preconditions.checkState(keys.size() == 1, "Unexpected number of elements for open type %s, should be 1", openType);
+ String mappingKey = keys.iterator().next();
+ return new SimpleIdentityRefAttributeReadingStrategy(lastAttribute.getNullableDefault(), mappingKey, identityMap);
+ }
+
@Override
protected AttributeReadingStrategy caseDependencyAttribute(SimpleType<?> openType) {
return new ObjectNameAttributeReadingStrategy(lastAttribute.getNullableDefault());
String textContent = "";
try{
- textContent = xmlElement.getTextContent();
+ textContent = readElementContent(xmlElement);
}catch(IllegalStateException | NullPointerException e) {
// yuma sends <attribute /> for empty value instead of <attribute></attribute>
logger.warn("Ignoring exception caused by failure to read text element", e);
postprocessParsedValue(textContent));
}
+ protected String readElementContent(XmlElement xmlElement) {
+ return xmlElement.getTextContent();
+ }
+
@Override
protected Object postprocessNullableDefault(String nullableDefault) {
return nullableDefault;
super(nullableDefault);
}
+ @Override
protected Object postprocessParsedValue(String textContent) {
BaseEncoding en = BaseEncoding.base64();
byte[] decode = en.decode(textContent);
this.key = key;
}
+ @Override
protected Object postprocessParsedValue(String textContent) {
HashMap<String,String> map = Maps.newHashMap();
map.put(key, textContent);
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * 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
+ */
+
+package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
+
+import java.net.URI;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfig;
+import org.opendaylight.controller.netconf.util.xml.XmlElement;
+import org.opendaylight.yangtools.yang.common.QName;
+
+
+public class SimpleIdentityRefAttributeReadingStrategy extends SimpleAttributeReadingStrategy {
+
+ private final String key;
+ private final Map<String, Map<Date, EditConfig.IdentityMapping>> identityMap;
+
+ public SimpleIdentityRefAttributeReadingStrategy(String nullableDefault, String key, Map<String, Map<Date,EditConfig.IdentityMapping>> identityMap) {
+ super(nullableDefault);
+ this.key = key;
+ this.identityMap = identityMap;
+ }
+
+ @Override
+ protected String readElementContent(XmlElement xmlElement) {
+ // TODO test
+ Map.Entry<String, String> namespaceOfTextContent = xmlElement.findNamespaceOfTextContent();
+ String content = xmlElement.getTextContent();
+
+ String prefix = namespaceOfTextContent.getKey() + ":";
+ Preconditions.checkArgument(content.startsWith(prefix), "Identity ref should be prefixed");
+
+ String localName = content.substring(prefix.length());
+ String namespace = namespaceOfTextContent.getValue();
+
+ Date revision = null;
+ Map<Date, EditConfig.IdentityMapping> revisions = identityMap.get(namespace);
+ if(revisions.keySet().size() > 1) {
+ for (Date date : revisions.keySet()) {
+ if(revisions.get(date).containsIdName(localName)) {
+ Preconditions.checkState(revision == null, "Duplicate identity %s, in namespace %s, with revisions: %s, %s detected. Cannot map attribute",
+ localName, namespace, revision, date);
+ revision = date;
+ }
+ }
+ } else
+ revision = revisions.keySet().iterator().next();
+
+
+ return QName.create(URI.create(namespace), revision, localName).toString();
+ }
+
+ @Override
+ protected Object postprocessParsedValue(String textContent) {
+ HashMap<String,String> map = Maps.newHashMap();
+ map.put(key, textContent);
+ return map;
+ }
+
+ @Override
+ protected Object postprocessNullableDefault(String nullableDefault) {
+ return nullableDefault == null ? null : postprocessParsedValue(nullableDefault);
+ }
+}
this.key = key;
}
+ @Override
protected Object postprocessParsedValue(String textContent) {
char[] charArray = textContent.toCharArray();
List<String> chars = Lists.newArrayListWithCapacity(charArray.length);
return new ArrayAttributeWritingStrategy(innerStrategy);
}
+ @Override
+ protected AttributeWritingStrategy caseJavaIdentityRefAttribute(OpenType<?> openType) {
+ return new SimpleIdentityRefAttributeWritingStrategy(document, key);
+ }
+
@Override
protected AttributeWritingStrategy caseJavaCompositeAttribute(CompositeType openType) {
return new SimpleCompositeAttributeWritingStrategy(document, key);
public void writeElement(Element parentElement, String namespace, Object value) {
value = preprocess(value);
Util.checkType(value, String.class);
- Element innerNode = XmlUtil.createTextElement(document, key, (String) value);
+ Element innerNode = createElement(document, key, (String) value);
XmlUtil.addNamespaceAttr(innerNode, namespace);
parentElement.appendChild(innerNode);
}
+ protected Element createElement(Document document, String key, String value) {
+ return XmlUtil.createTextElement(document, key, (String) value);
+ }
+
protected Object preprocess(Object value) {
return value;
}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * 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
+ */
+
+package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml;
+
+import java.util.Map;
+
+import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
+import org.opendaylight.controller.netconf.util.xml.XmlUtil;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.w3c.dom.Document;
+
+import com.google.common.base.Preconditions;
+import org.w3c.dom.Element;
+
+public class SimpleIdentityRefAttributeWritingStrategy extends SimpleAttributeWritingStrategy {
+
+ private static final char QNAME_SEPARATOR = ':';
+ private static final String PREFIX = "prefix";
+
+ /**
+ * @param document
+ * @param key
+ */
+ public SimpleIdentityRefAttributeWritingStrategy(Document document, String key) {
+ super(document, key);
+ }
+
+ protected Object preprocess(Object value) {
+ Util.checkType(value, Map.class);
+ Preconditions.checkArgument(((Map)value).size() == 1, "Unexpected number of values in %s, expected 1", value);
+ Object stringValue = ((Map) value).values().iterator().next();
+ Util.checkType(stringValue, String.class);
+
+ return stringValue;
+ }
+
+ @Override
+ protected Element createElement(Document doc, String key, String value) {
+ QName qName = QName.create(value);
+ String identity = qName.getLocalName();
+ Element element = XmlUtil.createPrefixedTextElement(doc, key, PREFIX, identity);
+
+ String identityNamespace = qName.getNamespace().toString();
+ XmlUtil.addPrefixedNamespaceAttr(element, PREFIX, identityNamespace);
+ return element;
+ }
+}
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
+import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfig;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditStrategyType;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import org.opendaylight.controller.netconf.util.xml.XmlNetconfConstants;
import javax.management.ObjectName;
import java.util.Collection;
import java.util.Collections;
+import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
Map<String /* Name of module entry from yang file */, ModuleConfig>> moduleConfigs;
private final Map<String, ModuleConfig> moduleNamesToConfigs;
+ private final Map<String, Map<Date, EditConfig.IdentityMapping>> identityMap;
+
public Config(Map<String, Map<String, ModuleConfig>> moduleConfigs) {
+ this(moduleConfigs, Collections.<String, Map<Date, EditConfig.IdentityMapping>>emptyMap());
+ }
+
+ public Config(Map<String, Map<String, ModuleConfig>> moduleConfigs, Map<String, Map<Date,EditConfig.IdentityMapping>> identityMap) {
this.moduleConfigs = moduleConfigs;
Map<String, ModuleConfig> moduleNamesToConfigs = new HashMap<>();
for (Entry<String, Map<String, ModuleConfig>> entry : moduleConfigs.entrySet()) {
moduleNamesToConfigs.putAll(entry.getValue());
}
this.moduleNamesToConfigs = Collections.unmodifiableMap(moduleNamesToConfigs);
+ this.identityMap = identityMap;
}
public static Map<String, Map<String, Collection<ObjectName>>> getMappedInstances(Set<ObjectName> instancesToMap,
@Override
public ModuleElementResolved resolveElement(ModuleConfig moduleMapping, XmlElement moduleElement, ServiceRegistryWrapper serviceTracker, String instanceName, String moduleNamespace, EditStrategyType defaultStrategy) {
return moduleMapping.fromXml(moduleElement, serviceTracker,
- instanceName, moduleNamespace, defaultStrategy);
+ instanceName, moduleNamespace, defaultStrategy, identityMap);
}
};
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.resolving.ObjectResolver;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml.AttributeWritingStrategy;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml.ObjectXmlWriter;
+import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfig;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditStrategyType;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import org.opendaylight.controller.netconf.util.xml.XmlNetconfConstants;
import javax.management.ObjectName;
import javax.management.openmbean.OpenType;
+import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
}
public InstanceConfigElementResolved fromXml(XmlElement moduleElement, ServiceRegistryWrapper services, String moduleNamespace,
- EditStrategyType defaultStrategy, Multimap<String, String> providedServices) {
+ EditStrategyType defaultStrategy, Multimap<String, String> providedServices, Map<String, Map<Date,EditConfig.IdentityMapping>> identityMap) {
Map<String, AttributeConfigElement> retVal = Maps.newHashMap();
- Map<String, AttributeReadingStrategy> strats = new ObjectXmlReader().prepareReading(yangToAttrConfig);
+ Map<String, AttributeReadingStrategy> strats = new ObjectXmlReader().prepareReading(yangToAttrConfig, identityMap);
List<XmlElement> recognisedChildren = Lists.newArrayList();
XmlElement type = moduleElement.getOnlyChildElementWithSameNamespace(XmlNetconfConstants.TYPE_KEY);
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
+import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfig;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditStrategyType;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import org.opendaylight.controller.netconf.util.xml.XmlNetconfConstants;
import javax.management.ObjectName;
import java.util.Collection;
+import java.util.Date;
+import java.util.Map;
public class ModuleConfig {
}
public ModuleElementResolved fromXml(XmlElement moduleElement, ServiceRegistryWrapper depTracker, String instanceName,
- String moduleNamespace, EditStrategyType defaultStrategy) {
+ String moduleNamespace, EditStrategyType defaultStrategy, Map<String, Map<Date,EditConfig.IdentityMapping>> identityMap) {
- InstanceConfigElementResolved ice = instanceConfig.fromXml(moduleElement, depTracker, moduleNamespace, defaultStrategy, providedServices);
+ InstanceConfigElementResolved ice = instanceConfig.fromXml(moduleElement, depTracker, moduleNamespace, defaultStrategy, providedServices, identityMap);
return new ModuleElementResolved(instanceName, ice);
}
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.opendaylight.controller.config.api.ServiceReferenceReadableRegistry;
+import org.opendaylight.yangtools.yang.common.QName;
import javax.management.InstanceNotFoundException;
import javax.management.ObjectName;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
public class ServiceRegistryWrapper {
ObjectName on = serviceMapping.get(serviceQName).get(refName);
Services.ServiceInstance si = Services.ServiceInstance.fromObjectName(on);
- // FIXME use QName's new String constructor, after it is fixed
-// QName qname;
-// try {
-// qname = new QName(serviceQName);
-// } catch (ParseException e) {
-// throw new IllegalStateException("Unable to parse qname of a service " + serviceQName, e);
-// }
- Pattern p = Pattern.compile("\\(([^\\(\\?]+)\\?[^\\?\\)]*\\)([^\\)]+)");
- Matcher matcher = p.matcher(serviceQName);
- Preconditions.checkArgument(matcher.matches());
- String namespace = matcher.group(1);
- String localName = matcher.group(2);
-
-// String namespace = qname.getNamespace().toString();
+ QName qname = QName.create(serviceQName);
+ String namespace = qname.getNamespace().toString();
Map<String, Map<String, String>> serviceToRefs = retVal.get(namespace);
if(serviceToRefs==null) {
serviceToRefs = Maps.newHashMap();
retVal.put(namespace, serviceToRefs);
}
-// String localName = qname.getLocalName();
+ String localName = qname.getLocalName();
Map<String, String> refsToSis = serviceToRefs.get(localName);
if(refsToSis==null) {
refsToSis = Maps.newHashMap();
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml.ObjectXmlReader;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.resolving.AttributeResolvingStrategy;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.resolving.ObjectResolver;
+import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfig;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import javax.management.openmbean.OpenType;
+import java.util.Collections;
+import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
public Map<String, AttributeConfigElement> fromXml(XmlElement configRootNode) {
Map<String, AttributeConfigElement> retVal = Maps.newHashMap();
- Map<String, AttributeReadingStrategy> strats = new ObjectXmlReader().prepareReading(yangToAttrConfig);
+ // FIXME add identity map to runtime data
+ Map<String, AttributeReadingStrategy> strats = new ObjectXmlReader().prepareReading(yangToAttrConfig,
+ Collections.<String, Map<Date, EditConfig.IdentityMapping>> emptyMap());
for (Entry<String, AttributeReadingStrategy> readStratEntry : strats.entrySet()) {
List<XmlElement> configNodes = configRootNode.getChildElements(readStratEntry.getKey());
package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import org.opendaylight.controller.config.api.JmxAttributeValidationException;
import org.opendaylight.controller.netconf.confignetconfconnector.transactions.TransactionProvider;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import org.opendaylight.controller.netconf.util.xml.XmlNetconfConstants;
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import javax.management.InstanceNotFoundException;
import javax.management.ObjectName;
+import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Set;
public class EditConfig extends AbstractConfigNetconfOperation {
}
}
- public static Config getConfigMapping(ConfigRegistryClient configRegistryClient,
- Map<String/* Namespace from yang file */,
- Map<String /* Name of module entry from yang file */, ModuleMXBeanEntry>> mBeanEntries) {
- Map<String, Map<String, ModuleConfig>> factories = transformMbeToModuleConfigs(configRegistryClient, mBeanEntries);
+ public static Config getConfigMapping(ConfigRegistryClient configRegistryClient, YangStoreSnapshot yangStoreSnapshot) {
+ Map<String, Map<String, ModuleConfig>> factories = transformMbeToModuleConfigs(configRegistryClient,
+ yangStoreSnapshot.getModuleMXBeanEntryMap());
+ Map<String, Map<Date, IdentityMapping>> identitiesMap = transformIdentities(yangStoreSnapshot.getModules());
+ return new Config(factories, identitiesMap);
+ }
+
+
+ public static class IdentityMapping {
+ private final Map<String, IdentitySchemaNode> identityNameToSchemaNode;
+
+ IdentityMapping() {
+ this.identityNameToSchemaNode = Maps.newHashMap();
+ }
- return new Config(factories);
+ void addIdSchemaNode(IdentitySchemaNode node) {
+ String name = node.getQName().getLocalName();
+ Preconditions.checkState(identityNameToSchemaNode.containsKey(name) == false);
+ identityNameToSchemaNode.put(name, node);
+ }
+
+ public boolean containsIdName(String idName) {
+ return identityNameToSchemaNode.containsKey(idName);
+ }
+
+ public IdentitySchemaNode getIdentitySchemaNode(String idName) {
+ Preconditions.checkState(identityNameToSchemaNode.containsKey(idName), "No identity under name %s", idName);
+ return identityNameToSchemaNode.get(idName);
+ }
+ }
+
+ private static Map<String, Map<Date, IdentityMapping>> transformIdentities(Set<Module> modules) {
+ Map<String, Map<Date, IdentityMapping>> mappedIds = Maps.newHashMap();
+ for (Module module : modules) {
+ String namespace = module.getNamespace().toString();
+ Map<Date, IdentityMapping> revisionsByNamespace= mappedIds.get(namespace);
+ if(revisionsByNamespace == null) {
+ revisionsByNamespace = Maps.newHashMap();
+ mappedIds.put(namespace, revisionsByNamespace);
+ }
+
+ Date revision = module.getRevision();
+ Preconditions.checkState(revisionsByNamespace.containsKey(revision) == false,
+ "Duplicate revision %s for namespace %s", revision, namespace);
+
+ IdentityMapping identityMapping = revisionsByNamespace.get(revision);
+ if(identityMapping == null) {
+ identityMapping = new IdentityMapping();
+ revisionsByNamespace.put(revision, identityMapping);
+ }
+
+ for (IdentitySchemaNode identitySchemaNode : module.getIdentities()) {
+ identityMapping.addIdSchemaNode(identitySchemaNode);
+ }
+
+ }
+
+ return mappedIds;
}
public static Map<String/* Namespace from yang file */,
protected Element handle(Document document, XmlElement xml) throws NetconfDocumentedException {
EditConfigXmlParser.EditConfigExecution editConfigExecution;
- Config cfg = getConfigMapping(configRegistryClient, yangStoreSnapshot.getModuleMXBeanEntryMap());
+ Config cfg = getConfigMapping(configRegistryClient, yangStoreSnapshot);
try {
editConfigExecution = editConfigXmlParser.fromXml(xml, cfg, transactionProvider, configRegistryClient);
} catch (IllegalStateException e) {
return getResponseInternal(document, editConfigExecution);
}
+
}
package org.opendaylight.controller.netconf.confignetconfconnector;
-import com.google.common.base.Optional;
-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 static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.math.BigInteger;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.management.InstanceAlreadyExistsException;
+import javax.management.InstanceNotFoundException;
+import javax.management.ObjectName;
+import javax.xml.parsers.ParserConfigurationException;
+
import org.apache.commons.lang3.StringUtils;
import org.junit.Before;
import org.junit.Ignore;
import org.opendaylight.controller.config.yang.test.impl.DtoAInnerInner;
import org.opendaylight.controller.config.yang.test.impl.DtoC;
import org.opendaylight.controller.config.yang.test.impl.DtoD;
+import org.opendaylight.controller.config.yang.test.impl.IdentityTestModuleFactory;
import org.opendaylight.controller.config.yang.test.impl.NetconfTestImplModuleFactory;
import org.opendaylight.controller.config.yang.test.impl.NetconfTestImplModuleMXBean;
import org.opendaylight.controller.config.yang.test.impl.Peers;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import org.opendaylight.controller.netconf.util.xml.XmlNetconfConstants;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.test.impl.rev130403.TestIdentity1;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.test.impl.rev130403.TestIdentity2;
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
+import org.opendaylight.yangtools.yang.data.impl.codec.IdentityCodec;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
-import javax.management.InstanceAlreadyExistsException;
-import javax.management.InstanceNotFoundException;
-import javax.management.ObjectName;
-import javax.xml.parsers.ParserConfigurationException;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.math.BigInteger;
-import java.net.URISyntaxException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
public class NetconfMappingTest extends AbstractConfigTest {
private static final String NETCONF_SESSION_ID = "foo";
private NetconfTestImplModuleFactory factory;
private DepTestImplModuleFactory factory2;
+ private IdentityTestModuleFactory factory3;
@Mock
YangStoreSnapshot yangStoreSnapshot;
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
doReturn(getMbes()).when(this.yangStoreSnapshot).getModuleMXBeanEntryMap();
+ doReturn(getModules()).when(this.yangStoreSnapshot).getModules();
+
this.factory = new NetconfTestImplModuleFactory();
this.factory2 = new DepTestImplModuleFactory();
- super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(this.factory, this.factory2));
+ this.factory3 = new IdentityTestModuleFactory();
+ super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(this.factory, this.factory2,
+ this.factory3));
transactionProvider = new TransactionProvider(this.configRegistryClient, NETCONF_SESSION_ID);
}
return on;
}
+ @Test
+ public void testIdentityRefs() throws Exception {
+ edit("netconfMessages/editConfig_identities.xml");
+
+ commit();
+ getConfigRunning();
+ }
+
+ @Override
+ protected CodecRegistry getCodecRegistry() {
+ IdentityCodec<?> idCodec = mock(IdentityCodec.class);
+ doReturn(TestIdentity1.class).when(idCodec).deserialize(TestIdentity1.QNAME);
+ doReturn(TestIdentity2.class).when(idCodec).deserialize(TestIdentity2.QNAME);
+
+ CodecRegistry codecReg = super.getCodecRegistry();
+ doReturn(idCodec).when(codecReg).getIdentityCodec();
+ return codecReg;
+ }
+
@Test
public void testServicePersistance() throws Exception {
createModule(INSTANCE_NAME);
edit("netconfMessages/editConfig.xml");
Element configCandidate = getConfigCandidate();
- System.err.println(XmlUtil.toString(configCandidate));
checkBinaryLeafEdited(configCandidate);
return mBeanEntries;
}
+ private Set<org.opendaylight.yangtools.yang.model.api.Module> getModules() throws Exception {
+ SchemaContext resolveSchemaContext = getSchemaContext();
+ return resolveSchemaContext.getModules();
+ }
+
+ private SchemaContext getSchemaContext() throws Exception {
+ final List<InputStream> yangDependencies = getYangs();
+ YangParserImpl parser = new YangParserImpl();
+
+ Set<Module> allYangModules = parser.parseYangModelsFromStreams(yangDependencies);
+
+ return parser.resolveSchemaContext(Sets
+ .newHashSet(allYangModules));
+ }
+
@Test
public void testConfigNetconfRuntime() throws Exception {
root.setAttribute(concat(XMLNS_ATTRIBUTE_KEY, prefix), namespace);
}
- public static Element createPrefixedTextElement(Document document, String key, String prefix, String moduleName) {
- return createTextElement(document, key, concat(prefix, moduleName));
+ public static Element createPrefixedTextElement(Document document, String key, String prefix, String content) {
+ return createTextElement(document, key, concat(prefix, content));
}
private static String concat(String prefix, String value) {
--- /dev/null
+<rpc message-id="a" a="64" xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+ <edit-config>
+ <target>
+ <candidate/>
+ </target>
+ <test-option>
+ set
+ </test-option>
+ <default-operation>merge</default-operation>
+ <config>
+ <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+ <module>
+ <type xmlns:test-impl="urn:opendaylight:params:xml:ns:yang:controller:test:impl">
+ test-impl:impl-identity-test
+ </type>
+ <name>id-test</name>
+ <identities>
+ <afi xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:test:impl">prefix:test-identity1</afi>
+ <safi xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:test:impl">prefix:test-identity2</safi>
+ </identities>
+ <identities>
+ <afi xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:test:impl">prefix:test-identity2</afi>
+ <safi xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:test:impl">prefix:test-identity1</safi>
+ </identities>
+ <identities-container>
+ <afi xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:test:impl">prefix:test-identity2</afi>
+ </identities-container>
+ <afi xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:test:impl">prefix:test-identity1</afi>
+ </module>
+ </modules>
+
+ <services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+
+ </services>
+ </config>
+ </edit-config>
+</rpc>
<version>1.0.1-SNAPSHOT</version>
<relativePath>opendaylight/commons/parent</relativePath>
</parent>
-
<artifactId>releasepom</artifactId>
<version>0.1.1-SNAPSHOT</version>
<packaging>pom</packaging>
Code Review / controller.git / commitdiff