Allow querying Config Registry and each transaction for set of qnames belonging to ModuleFactory classes.
This is helpful for netconf - allows checking for race conditions between yang store and config-manager.
Modify config code generator to add @ModuleQName annotation to each abstract factory class.
Change-Id: I6e8f972708883137610c09d274d52aedb1380120
Signed-off-by: Tomas Olvecky <tolvecky@cisco.com>
*/
boolean isHealthy();
+ /**
+ * @return module factory names available in the system
+ */
Set<String> getAvailableModuleNames();
+
+
/**
* Find all runtime beans
*
*/
void checkConfigBeanExists(ObjectName objectName) throws InstanceNotFoundException;
+ /**
+ * @return qnames of all ModuleFactory instances in the system
+ */
+ Set<String> getAvailableModuleFactoryQNames();
+
}
import org.opendaylight.controller.config.manager.impl.osgi.BeanToOsgiServiceManager;
import org.opendaylight.controller.config.manager.impl.osgi.BeanToOsgiServiceManager.OsgiRegistration;
import org.opendaylight.controller.config.manager.impl.util.LookupBeansUtil;
+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.osgi.framework.BundleContext;
private final ModuleFactoriesResolver resolver;
private final MBeanServer configMBeanServer;
- @GuardedBy("this")
- private final BundleContext bundleContext;
-
@GuardedBy("this")
private long version = 0;
@GuardedBy("this")
// internal jmx server shared by all transactions
private final MBeanServer transactionsMBeanServer;
+ // Used for finding new factory instances for default module functionality
@GuardedBy("this")
private List<ModuleFactory> lastListOfFactories = Collections.emptyList();
// constructor
public ConfigRegistryImpl(ModuleFactoriesResolver resolver,
- BundleContext bundleContext, MBeanServer configMBeanServer) {
- this(resolver, bundleContext, configMBeanServer,
+ MBeanServer configMBeanServer) {
+ this(resolver, configMBeanServer,
new BaseJMXRegistrator(configMBeanServer));
}
// constructor
public ConfigRegistryImpl(ModuleFactoriesResolver resolver,
- BundleContext bundleContext, MBeanServer configMBeanServer,
+ MBeanServer configMBeanServer,
BaseJMXRegistrator baseJMXRegistrator) {
this.resolver = resolver;
this.beanToOsgiServiceManager = new BeanToOsgiServiceManager();
- this.bundleContext = bundleContext;
this.configMBeanServer = configMBeanServer;
this.baseJMXRegistrator = baseJMXRegistrator;
this.registryMBeanServer = MBeanServerFactory
}
};
- ConfigTransactionLookupRegistry txLookupRegistry = new ConfigTransactionLookupRegistry(new TransactionIdentifier(
- transactionName), factory);
Map<String, Map.Entry<ModuleFactory, BundleContext>> allCurrentFactories = Collections.unmodifiableMap(
resolver.getAllFactories());
+ ConfigTransactionLookupRegistry txLookupRegistry = new ConfigTransactionLookupRegistry(new TransactionIdentifier(
+ transactionName), factory, allCurrentFactories);
ServiceReferenceWritableRegistry writableRegistry = ServiceReferenceRegistryImpl.createSRWritableRegistry(
readableSRRegistry, txLookupRegistry, allCurrentFactories);
public synchronized String getServiceInterfaceName(String namespace, String localName) {
return readableSRRegistry.getServiceInterfaceName(namespace, localName);
}
+
+ @Override
+ public Set<String> getAvailableModuleFactoryQNames() {
+ return ModuleQNameUtil.getQNames(resolver.getAllFactories());
+ }
+
}
/**
Collections.sort(result);
return result;
}
+
+
}
/**
import javax.management.InstanceNotFoundException;
import javax.management.MBeanServer;
import javax.management.ObjectName;
+import java.util.ArrayList;
+import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-import java.util.ArrayList;
-import java.util.Collection;
import java.util.concurrent.atomic.AtomicBoolean;
import static java.lang.String.format;
return txLookupRegistry.getTransactionIdentifier();
}
+ @Override
+ public Set<String> getAvailableModuleFactoryQNames() {
+ return txLookupRegistry.getAvailableModuleFactoryQNames();
+ }
+
}
import org.opendaylight.controller.config.manager.impl.jmx.TransactionJMXRegistrator;
import org.opendaylight.controller.config.manager.impl.jmx.TransactionModuleJMXRegistrator;
import org.opendaylight.controller.config.manager.impl.util.LookupBeansUtil;
+import org.opendaylight.controller.config.manager.impl.util.ModuleQNameUtil;
+import org.opendaylight.controller.config.spi.ModuleFactory;
+import org.osgi.framework.BundleContext;
import javax.management.InstanceAlreadyExistsException;
import javax.management.InstanceNotFoundException;
import javax.management.ObjectName;
import java.io.Closeable;
+import java.util.Map;
+import java.util.Map.Entry;
import java.util.Set;
/**
private final TransactionJMXRegistrator transactionJMXRegistrator;
private final TransactionIdentifier transactionIdentifier;
private final TransactionModuleJMXRegistrator txModuleJMXRegistrator;
+ private final Map<String, Map.Entry<ModuleFactory, BundleContext>> allCurrentFactories;
ConfigTransactionLookupRegistry(TransactionIdentifier transactionIdentifier,
- TransactionJMXRegistratorFactory factory) {
+ TransactionJMXRegistratorFactory factory, Map<String, Entry<ModuleFactory, BundleContext>> allCurrentFactories) {
this.transactionIdentifier = transactionIdentifier;
this.transactionJMXRegistrator = factory.create();
this.txModuleJMXRegistrator = transactionJMXRegistrator.createTransactionModuleJMXRegistrator();
+ this.allCurrentFactories = allCurrentFactories;
}
private void checkTransactionName(ObjectName objectName) {
public void registerMBean(ConfigTransactionControllerInternal transactionController, ObjectName controllerObjectName) throws InstanceAlreadyExistsException {
transactionJMXRegistrator.registerMBean(transactionController, controllerObjectName);
}
+
+ @Override
+ public Set<String> getAvailableModuleFactoryQNames() {
+ return ModuleQNameUtil.getQNames(allCurrentFactories);
+ }
+
}
interface TransactionJMXRegistratorFactory {
public void checkConfigBeanExists(ObjectName objectName) throws InstanceNotFoundException {
throw new InstanceNotFoundException("Cannot find " + objectName);
}
+
+ @Override
+ public Set<String> getAvailableModuleFactoryQNames() {
+ throw new UnsupportedOperationException();
+ }
};
return new ServiceReferenceRegistryImpl(Collections.<String, ModuleFactory>emptyMap(), lookupRegistry,
Collections.<String /* qName */, Map<String /* refName */, ModuleIdentifier>>emptyMap());
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.util.Map.Entry;
import java.util.Set;
import java.util.List;
import java.util.Map;
return moduleFactories;
}
+ public Map<String, Entry<ModuleFactory, BundleContext>> getModuleNamesToConfigBeanFactories() {
+ return moduleNamesToConfigBeanFactories;
+ }
}
new BundleContextBackedModuleFactoriesResolver(context);
MBeanServer configMBeanServer = ManagementFactory.getPlatformMBeanServer();
configRegistry = new ConfigRegistryImpl(
- bundleContextBackedModuleFactoriesResolver, context,
- configMBeanServer);
+ bundleContextBackedModuleFactoriesResolver, configMBeanServer);
// register config registry to OSGi
configRegistryServiceRegistration = context.registerService(ConfigRegistryImpl.class, configRegistry, null);
--- /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.util;
+
+import org.opendaylight.controller.config.spi.ModuleFactory;
+import org.opendaylight.yangtools.yang.binding.annotations.ModuleQName;
+import org.osgi.framework.BundleContext;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public class ModuleQNameUtil {
+
+ public static Set<String> getQNames(Map<String, Entry<ModuleFactory, BundleContext>> resolved) {
+ Set<String> result = new HashSet<>();
+ for (Entry<ModuleFactory, BundleContext> entry : resolved.values()) {
+ Class<?> inspected = entry.getKey().getClass();
+ if (inspected.isInterface()) {
+ throw new IllegalArgumentException("Unexpected interface " + inspected);
+ }
+ ModuleQName annotation = null;
+ while(annotation == null && inspected != null) {
+ annotation = inspected.getAnnotation(ModuleQName.class);
+ inspected = inspected.getSuperclass();
+ }
+ if (annotation != null) {
+ // FIXME
+ String qName = "(" + annotation.namespace() + "?revision=" + annotation.revision() + ")" + annotation.name();
+ result.add(qName);
+ }
+ }
+ return result;
+ }
+
+}
factory, factory);
configRegistry = new ConfigRegistryImpl(resolver,
- context, ManagementFactory.getPlatformMBeanServer());
+ ManagementFactory.getPlatformMBeanServer());
configRegistry.beginConfig();
fail();
internalJmxRegistrator = new InternalJMXRegistrator(platformMBeanServer);
baseJmxRegistrator = new BaseJMXRegistrator(internalJmxRegistrator);
- configRegistry = new ConfigRegistryImpl(resolver, mockedContext,
+ configRegistry = new ConfigRegistryImpl(resolver,
platformMBeanServer, baseJmxRegistrator);
try {
configRegistryJMXRegistrator.registerToJMX(configRegistry);
@Before
public void setUp() throws Exception {
- configRegistryImpl = new ConfigRegistryImpl(null, null,
+ configRegistryImpl = new ConfigRegistryImpl(null,
ManagementFactory.getPlatformMBeanServer());
Field field = configRegistryImpl.getClass().getDeclaredField(
"baseJMXRegistrator");
public TransactionJMXRegistrator create() {
return baseJMXRegistrator.createTransactionJMXRegistrator(transactionName123);
}
- });
+ }, currentlyRegisteredFactories);
ServiceReferenceWritableRegistry writableRegistry = ServiceReferenceRegistryImpl.createSRWritableRegistry(
ServiceReferenceRegistryImpl.createInitialSRLookupRegistry(), txLookupRegistry, currentlyRegisteredFactories);
--- /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.testingservices.threadpool;
+
+import org.opendaylight.yangtools.yang.binding.annotations.ModuleQName;
+
+@ModuleQName(namespace = "namespace", revision = "revision", name = "name")
+public abstract class AbstractTestingFixedThreadPoolModuleFactory {
+}
import java.util.HashSet;
import java.util.Set;
-public class TestingFixedThreadPoolModuleFactory implements ModuleFactory {
+public class TestingFixedThreadPoolModuleFactory extends AbstractTestingFixedThreadPoolModuleFactory implements ModuleFactory {
public static final String NAME = "fixed";
private static Set<Class<? extends AbstractServiceInterface>> ifc = Collections.unmodifiableSet(Sets.newHashSet(
*/
package org.opendaylight.controller.config.manager.testingservices.threadpool.test;
+import com.google.common.collect.Sets;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.concurrent.ThreadPoolExecutor;
import static org.junit.Assert.assertEquals;
}
+ @Test
+ public void testQNames() {
+ Set<String> availableModuleFactoryQNames = configRegistryClient.getAvailableModuleFactoryQNames();
+ String expected = "(namespace?revision=revision)name";
+ assertEquals(Sets.newHashSet(expected), availableModuleFactoryQNames);
+ }
+
}
*/
package org.opendaylight.controller.config.util;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import org.opendaylight.controller.config.api.ConflictingVersionException;
+import org.opendaylight.controller.config.api.ValidationException;
+import org.opendaylight.controller.config.api.jmx.CommitStatus;
+import org.opendaylight.controller.config.api.jmx.ConfigRegistryMXBean;
+import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
import javax.management.AttributeNotFoundException;
import javax.management.InstanceNotFoundException;
import javax.management.ObjectInstance;
import javax.management.ObjectName;
import javax.management.ReflectionException;
-
-import org.opendaylight.controller.config.api.ConflictingVersionException;
-import org.opendaylight.controller.config.api.ValidationException;
-import org.opendaylight.controller.config.api.jmx.CommitStatus;
-import org.opendaylight.controller.config.api.jmx.ConfigRegistryMXBean;
-import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
public class ConfigRegistryJMXClient implements ConfigRegistryClient {
private final ConfigRegistryMXBean configRegistryMXBeanProxy;
}
}
+ @Override
+ public Set<String> getAvailableModuleFactoryQNames() {
+ return configRegistryMXBeanProxy.getAvailableModuleFactoryQNames();
+ }
}
+ attrName + " for " + on, e);
}
}
+
+ @Override
+ public Set<String> getAvailableModuleFactoryQNames() {
+ return configTransactionControllerMXBeanProxy.getAvailableModuleFactoryQNames();
+ }
}
public String getServiceInterfaceName(String namespace, String localName) {
throw new UnsupportedOperationException();
}
+
+ @Override
+ public Set<String> getAvailableModuleFactoryQNames() {
+ throw new UnsupportedOperationException();
+ }
}
public boolean removeServiceReferences(ObjectName objectName) throws InstanceNotFoundException {
throw new UnsupportedOperationException();
}
+
+ @Override
+ public Set<String> getAvailableModuleFactoryQNames() {
+ throw new UnsupportedOperationException();
+ }
}
import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface;
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.spi.ModuleFactory;
+import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
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;
private final String globallyUniqueName, moduleInstanceType;
private final List<String> providedServices;
+ private final ModuleMXBeanEntry mbe;
public AbstractFactoryTemplate(Header header, String packageName,
- String abstractFactoryName, String globallyUniqueName,
- String moduleInstanceType, List<Field> fields,
- List<String> providedServices) {
+ String abstractFactoryName, String globallyUniqueName,
+ String moduleInstanceType, List<Field> fields,
+ List<String> providedServices, ModuleMXBeanEntry mbe) {
super(header, packageName, abstractFactoryName, Collections
.<String> emptyList(), implementedIfcs, fields, Collections
.<MethodDefinition> emptyList(), true, false, Collections
this.globallyUniqueName = globallyUniqueName;
this.moduleInstanceType = moduleInstanceType;
this.providedServices = providedServices;
+ this.mbe = mbe;
}
public String getGloballyUniqueName() {
return "factory_abs_template.ftl";
}
+ public ModuleMXBeanEntry getMbe() {
+ return mbe;
+ }
}
sieTemplate.getAnnotations().add(
Annotation.createDescriptionAnnotation(sie
.getNullableDescription()));
- sieTemplate.getAnnotations().add(Annotation.createSieAnnotation(sie.getQName(), sie.getExportedOsgiClassName
- ()));
+ sieTemplate.getAnnotations().addAll(Annotation.createSieAnnotations(sie));
return sieTemplate;
}
mbe.getPackageName(), mbe.getAbstractFactoryName(),
mbe.getGloballyUniqueName(), mbe.getFullyQualifiedName(mbe
.getStubModuleName()), attrProcessor.getFields(),
- Lists.newArrayList(transformed));
+ Lists.newArrayList(transformed), mbe);
}
public static AbstractModuleTemplate abstractModuleTemplateFromMbe(
*/
package org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model;
+import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
import org.opendaylight.controller.config.api.annotations.Description;
import org.opendaylight.controller.config.api.annotations.RequireInterface;
import org.opendaylight.controller.config.api.annotations.ServiceInterfaceAnnotation;
+import org.opendaylight.yangtools.yang.binding.annotations.ModuleQName;
import org.opendaylight.controller.config.yangjmxgenerator.ServiceInterfaceEntry;
-import org.opendaylight.yangtools.yang.common.QName;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
Lists.newArrayList(new Parameter("value", q(description))));
}
- public static Annotation createSieAnnotation(QName qname,
- String exportedClassName) {
- Preconditions.checkNotNull(qname,
+ public static Collection<Annotation> createSieAnnotations(ServiceInterfaceEntry sie){
+
+ String exportedClassName = sie.getExportedOsgiClassName();
+ Preconditions.checkNotNull(sie.getQName(),
"Cannot create annotation from null qname");
Preconditions.checkNotNull(exportedClassName,
"Cannot create annotation from null exportedClassName");
+ List<Annotation> result = new ArrayList<>();
+ {
+ List<Parameter> params = Lists.newArrayList(new Parameter("value", q(sie.getQName().toString())));
+ params.add(new Parameter("osgiRegistrationType", exportedClassName + ".class"));
- List<Parameter> params = Lists.newArrayList(new Parameter("value", q(qname.toString())));
- params.add(new Parameter("osgiRegistrationType", exportedClassName + ".class"));
+ params.add(new Parameter("namespace", q(sie.getQName().getNamespace().toString())));
+ params.add(new Parameter("revision", q(sie.getQName().getFormattedRevision())));
+ params.add(new Parameter("localName", q(sie.getQName().getLocalName())));
- params.add(new Parameter("namespace", q(qname.getNamespace().toString())));
- params.add(new Parameter("revision", q(qname.getFormattedRevision())));
- params.add(new Parameter("localName", q(qname.getLocalName())));
+ Annotation sieAnnotation = new Annotation(ServiceInterfaceAnnotation.class.getCanonicalName(), params);
+ result.add(sieAnnotation);
- return new Annotation(
- ServiceInterfaceAnnotation.class.getCanonicalName(), params);
+ }
+ {
+ List<Parameter> params = new ArrayList<>();
+ params.add(new Parameter("namespace", q(sie.getYangModuleQName().getNamespace().toString())));
+ params.add(new Parameter("revision", q(sie.getYangModuleQName().getFormattedRevision())));
+ params.add(new Parameter("name", q(sie.getYangModuleQName().getLocalName())));
+
+ Annotation moduleQNameAnnotation = new Annotation(ModuleQName.class.getCanonicalName(), params);
+ result.add(moduleQNameAnnotation);
+ }
+ return result;
}
public static Annotation createRequireIfcAnnotation(
package ${packageName};
<@javadocD object=javadoc/>
+@org.opendaylight.yangtools.yang.binding.annotations.ModuleQName(namespace="${mbe.getYangModuleQName().getNamespace().toString()}",revision="${mbe.getYangModuleQName().getFormattedRevision()}",name="${mbe.getYangModuleQName().getLocalName()}")
<@typeDeclarationD object=typeDeclaration/>
{
private final Map<String, QName> providedServices;
private Collection<RuntimeBeanEntry> runtimeBeans;
+ private final QName yangModuleQName;
public ModuleMXBeanEntry(IdentitySchemaNode id,
Map<String, AttributeIfc> yangToAttributes, String packageName,
Map<String, QName> providedServices2, String javaNamePrefix,
- String namespace, Collection<RuntimeBeanEntry> runtimeBeans) {
+ String namespace, Collection<RuntimeBeanEntry> runtimeBeans,
+ QName yangModuleQName) {
this.globallyUniqueName = id.getQName().getLocalName();
this.yangToAttributes = yangToAttributes;
this.nullableDescription = id.getDescription();
this.namespace = checkNotNull(namespace);
this.providedServices = Collections.unmodifiableMap(providedServices2);
this.runtimeBeans = runtimeBeans;
+ this.yangModuleQName = yangModuleQName;
}
public String getMXBeanInterfaceName() {
moduleIdentity, yangToAttributes, packageName,
providedServices, javaNamePrefix, currentModule
.getNamespace().toString(),
- runtimeBeans);
+ runtimeBeans,
+ ModuleUtil.getQName(currentModule));
moduleMXBeanEntry.setYangModuleName(currentModule
.getName());
moduleMXBeanEntry
return nullableDescription;
}
+ public QName getYangModuleQName() {
+ return yangModuleQName;
+ }
+
@Override
public String toString() {
return "ModuleMXBeanEntry{" + "globallyUniqueName='"
--- /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;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.Module;
+
+public class ModuleUtil {
+
+ public static QName getQName(Module currentModule){
+ return new QName(currentModule.getNamespace(), currentModule.getRevision(), currentModule.getName());
+ }
+}
private final String exportedOsgiClassName;
private final QName qName;
private final String nullableDescription, packageName, typeName;
+ private final QName yangModuleQName;
- private ServiceInterfaceEntry(IdentitySchemaNode id, String packageName) {
- this(Optional.<ServiceInterfaceEntry> absent(), id, packageName);
+ private ServiceInterfaceEntry(IdentitySchemaNode id, String packageName, QName yangModuleQName) {
+ this(Optional.<ServiceInterfaceEntry> absent(), id, packageName, yangModuleQName);
}
private ServiceInterfaceEntry(Optional<ServiceInterfaceEntry> base,
- IdentitySchemaNode id, String packageName) {
+ IdentitySchemaNode id, String packageName, QName yangModuleQName) {
checkNotNull(base);
this.maybeBaseCache = base;
List<UnknownSchemaNode> unknownSchemaNodes = id.getUnknownSchemaNodes();
nullableDescription = id.getDescription();
typeName = getSimpleName(exportedOsgiClassName) + CLASS_NAME_SUFFIX;
this.packageName = packageName;
+ this.yangModuleQName = yangModuleQName;
}
private static final String getSimpleName(String fullyQualifiedName) {
* @return Map of QNames as keys and ServiceInterfaceEntry instances as
* values
*/
- public static Map<QName, ServiceInterfaceEntry> create(Module module,
+ public static Map<QName, ServiceInterfaceEntry> create(Module currentModule,
String packageName) {
logger.debug("Generating ServiceInterfaces from {} to package {}",
- module.getNamespace(), packageName);
+ currentModule.getNamespace(), packageName);
Map<IdentitySchemaNode, ServiceInterfaceEntry> identitiesToSIs = new HashMap<>();
Set<IdentitySchemaNode> notVisited = new HashSet<>(
- module.getIdentities());
+ currentModule.getIdentities());
int lastSize = notVisited.size() + 1;
while (notVisited.size() > 0) {
if (notVisited.size() == lastSize) {
} else if (identity.getBaseIdentity().getQName()
.equals(SERVICE_TYPE_Q_NAME)) {
// this is a base type
- created = new ServiceInterfaceEntry(identity, packageName);
+ created = new ServiceInterfaceEntry(identity, packageName, ModuleUtil.getQName(currentModule));
} else {
ServiceInterfaceEntry foundBase = identitiesToSIs
.get(identity.getBaseIdentity());
// derived type, did we convert the parent?
if (foundBase != null) {
created = new ServiceInterfaceEntry(
- Optional.of(foundBase), identity, packageName);
+ Optional.of(foundBase), identity, packageName, ModuleUtil.getQName(currentModule));
}
}
if (created != null) {
- created.setYangModuleName(module.getName());
+ created.setYangModuleName(currentModule.getName());
// TODO how to get local name
created.setYangModuleLocalname(identity.getQName()
.getLocalName());
return typeName;
}
+ public QName getYangModuleQName() {
+ return yangModuleQName;
+ }
+
@Override
public boolean equals(Object o) {
if (this == o)