Examples with DataSchemaNode org.opendaylight.yangtools.yang.model.api.DataSchemaNode used on opensource projects

Example 6 with DataSchemaNode

use of org.opendaylight.yangtools.yang.model.api.DataSchemaNode in project controller by opendaylight.

the class DataStoreAppConfigDefaultXMLReader method createDefaultInstance.

@SuppressWarnings("unchecked")
public T createDefaultInstance(final FallbackConfigProvider fallback) throws ConfigXMLReaderException, URISyntaxException, ParserConfigurationException, XMLStreamException, SAXException, IOException {
    YangInstanceIdentifier yangPath = bindingSerializer.toYangInstanceIdentifier(bindingContext.appConfigPath);
    LOG.debug("{}: Creating app config instance from path {}, Qname: {}", logName, yangPath, bindingContext.bindingQName);
    checkNotNull(schemaService, "%s: Could not obtain the SchemaService OSGi service", logName);
    SchemaContext schemaContext = schemaService.getGlobalContext();
    Module module = schemaContext.findModule(bindingContext.bindingQName.getModule()).orElse(null);
    checkNotNull(module, "%s: Could not obtain the module schema for namespace %s, revision %s", logName, bindingContext.bindingQName.getNamespace(), bindingContext.bindingQName.getRevision());
    DataSchemaNode dataSchema = module.getDataChildByName(bindingContext.bindingQName);
    checkNotNull(dataSchema, "%s: Could not obtain the schema for %s", logName, bindingContext.bindingQName);
    checkCondition(bindingContext.schemaType.isAssignableFrom(dataSchema.getClass()), "%s: Expected schema type %s for %s but actual type is %s", logName, bindingContext.schemaType, bindingContext.bindingQName, dataSchema.getClass());
    NormalizedNode<?, ?> dataNode = parsePossibleDefaultAppConfigXMLFile(schemaContext, dataSchema);
    if (dataNode == null) {
        dataNode = fallback.get(schemaService.getGlobalContext(), dataSchema);
    }
    DataObject appConfig = bindingSerializer.fromNormalizedNode(yangPath, dataNode).getValue();
    // This shouldn't happen but need to handle it in case...
    checkNotNull(appConfig, "%s: Could not create instance for app config binding %s", logName, bindingContext.appConfigBindingClass);
    return (T) appConfig;
}

Example 7 with DataSchemaNode

use of org.opendaylight.yangtools.yang.model.api.DataSchemaNode in project controller by opendaylight.

the class ModuleMXBeanEntryTest method testThreadsJava.

@Test
public void testThreadsJava() {
    final Map<String, ModuleMXBeanEntry> /* identity local name */
    namesToMBEs = loadThreadsJava();
    {
        // check threadpool-dynamic
        final ModuleMXBeanEntry dynamicThreadPool = namesToMBEs.get(THREADPOOL_DYNAMIC_MXB_NAME);
        final Map<String, AttributeIfc> attributes = dynamicThreadPool.getAttributes();
        // core-size, keepalive, maximum-size
        // threadfactory
        final Set<String> longAttribs = Sets.newHashSet("core-size", "maximum-size");
        for (final String longAttrib : longAttribs) {
            final TypedAttribute attribute = (TypedAttribute) attributes.get(longAttrib);
            assertThat("Failed to check " + longAttrib, attribute.getType(), is((Type) Types.typeForClass(Long.class)));
        }
        // check dependency on thread factory
        final QName threadfactoryQName = QName.create(THREADS_NAMESPACE, THREADS_REVISION_DATE, "threadfactory");
        final ServiceInterfaceEntry threadFactorySIEntry = this.modulesToSIEs.get(threadfactoryQName);
        assertNotNull(threadFactorySIEntry);
        final boolean expectedMandatory = true;
        final TypedAttribute actualThreadFactory = (TypedAttribute) attributes.get("threadfactory");
        final DataSchemaNode mockedDataSchemaNode = mock(DataSchemaNode.class);
        doReturn(Collections.emptyList()).when(mockedDataSchemaNode).getUnknownSchemaNodes();
        doReturn(threadfactoryQName).when(mockedDataSchemaNode).getQName();
        final AttributeIfc expectedDependencyAttribute = new DependencyAttribute(mockedDataSchemaNode, threadFactorySIEntry, expectedMandatory, "threadfactory description");
        assertThat(actualThreadFactory, is(expectedDependencyAttribute));
        assertThat(dynamicThreadPool.getFullyQualifiedName("DynamicThreadPoolModuleMXBean"), is(PACKAGE_NAME + ".DynamicThreadPoolModuleMXBean"));
        assertThat(dynamicThreadPool.getNullableDescription(), is("threadpool-dynamic description"));
        assertThat(dynamicThreadPool.getYangModuleName(), is("config-threads-java"));
        assertThat(dynamicThreadPool.getYangModuleLocalname(), is(THREADPOOL_DYNAMIC_MXB_NAME));
        // check root runtime bean
        final Collection<RuntimeBeanEntry> runtimeBeans = dynamicThreadPool.getRuntimeBeans();
        assertThat(runtimeBeans.size(), is(1));
        final RuntimeBeanEntry rootRB = findFirstByYangName(runtimeBeans, THREADPOOL_DYNAMIC_MXB_NAME);
        assertThat(rootRB.isRoot(), is(true));
        assertThat(rootRB.getAttributes().size(), is(1));
        final JavaAttribute attribute = (JavaAttribute) rootRB.getAttributes().iterator().next();
        assertThat(attribute.getAttributeYangName(), is("created-sessions"));
        assertThat(rootRB.getYangName(), is(THREADPOOL_DYNAMIC_MXB_NAME));
        assertThat(attribute.getType().getFullyQualifiedName(), is(Long.class.getName()));
    }
    {
        // check threadfactory-naming
        final ModuleMXBeanEntry threadFactoryNaming = namesToMBEs.get(THREADFACTORY_NAMING_MXB_NAME);
        final Collection<RuntimeBeanEntry> runtimeBeans = threadFactoryNaming.getRuntimeBeans();
        assertThat(runtimeBeans.size(), is(4));
        {
            final RuntimeBeanEntry threadRB = findFirstByYangName(runtimeBeans, "thread");
            assertNotNull(threadRB);
            assertFalse(threadRB.isRoot());
            assertEquals("name", threadRB.getKeyYangName().get());
            assertEquals("Name", threadRB.getKeyJavaName().get());
            assertThat(threadRB.getAttributes().size(), is(1));
            final AttributeIfc threadNameAttr = threadRB.getAttributes().iterator().next();
            assertThat(threadNameAttr.getAttributeYangName(), is("name"));
            assertTrue(threadNameAttr instanceof JavaAttribute);
            assertThat(((JavaAttribute) threadNameAttr).getType().getFullyQualifiedName(), is(String.class.getName()));
            assertThat(threadRB.getRpcs().size(), is(2));
        }
        {
            final RuntimeBeanEntry streamRB = findFirstByNamePrefix(runtimeBeans, "ThreadStream");
            assertNotNull(streamRB);
            assertFalse(streamRB.getKeyYangName().isPresent());
            assertFalse(streamRB.getKeyJavaName().isPresent());
            final Map<String, AttributeIfc> attributeMap = streamRB.getYangPropertiesToTypesMap();
            assertEquals(4, attributeMap.size());
            final TOAttribute toAttr = (TOAttribute) attributeMap.get("peer");
            assertNotNull(toAttr);
            assertThat(toAttr.getAttributeYangName(), is("peer"));
            assertThat(toAttr.getLowerCaseCammelCase(), is("peer"));
            assertThat(toAttr.getUpperCaseCammelCase(), is("Peer"));
            assertThat(toAttr.getOpenType(), isA(CompositeType.class));
            Set<String> propsExpected = new HashSet<>(2);
            propsExpected.add("port");
            propsExpected.add("core-size");
            assertThat(toAttr.getYangPropertiesToTypesMap().keySet(), is(propsExpected));
            propsExpected = new HashSet<>(2);
            propsExpected.add("Port");
            propsExpected.add("CoreSize");
            assertThat(toAttr.getCapitalizedPropertiesToTypesMap().keySet(), is(propsExpected));
            propsExpected = new HashSet<>(2);
            propsExpected.add("port");
            propsExpected.add("coreSize");
            assertThat(toAttr.getJmxPropertiesToTypesMap().keySet(), is(propsExpected));
            final JavaAttribute timestampAttr = (JavaAttribute) attributeMap.get("timestamp");
            assertNotNull(timestampAttr);
            final JavaAttribute stateAttr = (JavaAttribute) attributeMap.get("state");
            assertNotNull(stateAttr);
            final ListAttribute innerStream = (ListAttribute) attributeMap.get("inner-stream-list");
            assertNotNull(innerStream);
            assertThat(innerStream.getAttributeYangName(), is("inner-stream-list"));
            assertThat(innerStream.getLowerCaseCammelCase(), is("innerStreamList"));
            assertThat(innerStream.getUpperCaseCammelCase(), is("InnerStreamList"));
            assertThat(innerStream.getOpenType(), isA(ArrayType.class));
        }
    }
    {
        // test multiple dependencies
        final ModuleMXBeanEntry threadPoolRegistry = namesToMBEs.get(THREADPOOL_REGISTRY_IMPL_NAME);
        final Map<String, AttributeIfc> attributes = threadPoolRegistry.getAttributes();
        assertEquals(1, attributes.size());
        final AttributeIfc threadpoolsAttr = attributes.get("threadpools");
        assertNotNull(threadpoolsAttr);
        assertTrue(threadpoolsAttr instanceof ListDependenciesAttribute);
        final ListDependenciesAttribute threadpools = (ListDependenciesAttribute) threadpoolsAttr;
    }
}

Example 8 with DataSchemaNode

use of org.opendaylight.yangtools.yang.model.api.DataSchemaNode in project controller by opendaylight.

the class ModuleMXBeanEntryBuilder method build.

public Map<String, ModuleMXBeanEntry> build() {
    LOG.debug("Generating ModuleMXBeans of {} to package {}", currentModule.getNamespace(), packageName);
    String configModulePrefix;
    try {
        configModulePrefix = getConfigModulePrefixFromImport(currentModule);
    } catch (IllegalArgumentException e) {
        // this currentModule does not import config currentModule
        return Collections.emptyMap();
    }
    // get identities of base config:currentModule-type
    Map<String, IdentitySchemaNode> moduleIdentities = getIdentityMap();
    Map<String, QName> uniqueGeneratedClassesNames = new HashMap<>();
    // each currentModule name should have an augmentation defined
    Map<String, IdentitySchemaNode> unaugmentedModuleIdentities = new HashMap<>(moduleIdentities);
    Map<String, ModuleMXBeanEntry> result = new HashMap<>();
    for (AugmentationSchemaNode augmentation : currentModule.getAugmentations()) {
        Collection<DataSchemaNode> childNodes = augmentation.getChildNodes();
        if (areAllChildrenCaseSchemaNodes(childNodes)) {
            for (CaseSchemaNode childCase : castChildNodesToChoiceCases(childNodes)) {
                // TODO refactor, extract to standalone builder class
                processCaseSchemaNode(result, uniqueGeneratedClassesNames, configModulePrefix, moduleIdentities, unaugmentedModuleIdentities, augmentation, childCase);
            }
        }
    // skip if child nodes are not all cases
    }
    // clean up nulls
    cleanUpNulls(result);
    // check attributes name uniqueness
    checkAttributeNamesUniqueness(uniqueGeneratedClassesNames, result);
    checkUnaugumentedIdentities(unaugmentedModuleIdentities);
    LOG.debug("Number of ModuleMXBeans to be generated: {}", result.size());
    return result;
}

Example 9 with DataSchemaNode

use of org.opendaylight.yangtools.yang.model.api.DataSchemaNode in project controller by opendaylight.

the class ModuleMXBeanEntryBuilder method extractDependency.

private static Optional<? extends AbstractDependencyAttribute> extractDependency(final DataNodeContainer dataNodeContainer, final DataSchemaNode attrNode, final Module currentModule, final Map<QName, ServiceInterfaceEntry> qNamesToSIEs, final SchemaContext schemaContext) {
    if (isDependencyContainer(dataNodeContainer)) {
        // reference
        UsesNode usesNode = dataNodeContainer.getUses().iterator().next();
        for (SchemaNode refineNode : usesNode.getRefines().values()) {
            // this will ignore name nodes, since they are not needed here
            if (TYPE.equals(refineNode.getQName().getLocalName())) {
                checkState(refineNode.getUnknownSchemaNodes().size() == 1, "Unexpected unknown schema node size of " + refineNode);
                UnknownSchemaNode requiredIdentity = refineNode.getUnknownSchemaNodes().iterator().next();
                checkState(ConfigConstants.REQUIRED_IDENTITY_EXTENSION_QNAME.equals(requiredIdentity.getNodeType()), "Unexpected language extension " + requiredIdentity);
                String prefixAndIdentityLocalName = requiredIdentity.getNodeParameter();
                // import should point to a module
                ServiceInterfaceEntry serviceInterfaceEntry = findSIE(prefixAndIdentityLocalName, currentModule, qNamesToSIEs, schemaContext);
                LeafSchemaNode refine = (LeafSchemaNode) usesNode.getRefines().values().iterator().next();
                boolean mandatory = refine.isMandatory();
                AbstractDependencyAttribute reference;
                if (dataNodeContainer instanceof ContainerSchemaNode) {
                    reference = new DependencyAttribute(attrNode, serviceInterfaceEntry, mandatory, attrNode.getDescription().orElse(null));
                } else {
                    reference = new ListDependenciesAttribute(attrNode, serviceInterfaceEntry, mandatory, attrNode.getDescription().orElse(null));
                }
                return Optional.of(reference);
            }
        }
    }
    return Optional.absent();
}