org.jboss.staxmapper.XMLElementReader Java Examples

@SuppressWarnings("unchecked")
private void configureFractionsFromXML(Container container, List<ModelNode> operationList) throws Exception {

    StandaloneXmlParser parser = new StandaloneXmlParser();

    FractionProcessor<StandaloneXmlParser> consumer = (p, cfg, fraction) -> {
        try {
            if (cfg.getSubsystemParsers().isPresent()) {
                Map<QName, XMLElementReader<List<ModelNode>>> fractionParsers =
                        (Map<QName, XMLElementReader<List<ModelNode>>>) cfg.getSubsystemParsers().get();

                fractionParsers.forEach(p::addDelegate);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };

    // collect parsers
    visitFractions(container, parser, consumer);

    // parse the configurations
    List<ModelNode> parseResult = parser.parse(xmlConfig.get());
    operationList.addAll(parseResult);

}
 

public GitConfigurationPersister(GitRepository gitRepository, ConfigurationFile file, QName rootElement, XMLElementReader<List<ModelNode>> rootParser,
        XMLElementWriter<ModelMarshallingContext> rootDeparser, boolean suppressLoad) {
    super(file.getBootFile(), rootElement, rootParser, rootDeparser, suppressLoad);
    root = file.getConfigurationDir().getParentFile().toPath();
    mainFile = file.getMainFile();
    this.gitRepository = gitRepository;
    File baseDir = root.toFile();
    try {
        File gitDir = new File(baseDir, Constants.DOT_GIT);
        if(!gitDir.exists()) {
            gitDir.mkdir();
        }
        if (gitRepository.isBare()) {
            Git.init().setDirectory(baseDir).setGitDir(gitDir).call();
            ServerLogger.ROOT_LOGGER.gitRespositoryInitialized(baseDir.getAbsolutePath());
        }
    } catch (IllegalStateException | GitAPIException e) {
        ControllerLogger.ROOT_LOGGER.error(e);
    }
}
 

@Override
public void setSubsystemXmlMapping(String subsystemName, String namespaceUri, Supplier<XMLElementReader<List<ModelNode>>> supplier){
    assert subsystemName != null : "subsystemName is null";
    assert namespaceUri != null : "namespaceUri is null";
    synchronized (extension) {
        extension.getSubsystemInfo(subsystemName).addParsingNamespace(namespaceUri);
        if (extension.xmlMapper != null) {
            extension.xmlMapper.registerRootElement(new QName(namespaceUri, SUBSYSTEM), supplier);
            if (!hasNonSupplierParser) {
                if (latestNamespace == null || latestNamespace.compareTo(namespaceUri) < 0) {
                    latestNamespace = namespaceUri;
                    latestSupplier = supplier;
                }
            }
        }
    }
}
 

@Override
public Map<QName, XMLElementReader<List<ModelNode>>> create() {
    ParsingContext ctx = new ParsingContext();
    JaxrsExtension ext = new JaxrsExtension();
    ext.initializeParsers(ctx);
    return ctx.getParser();

}
 

@Override
public Map<QName, XMLElementReader<List<ModelNode>>> create() {
    ParsingContext ctx = new ParsingContext();
    IOExtension ext = new IOExtension();
    ext.initializeParsers(ctx);
    return ctx.getParser();
}
 

public static List<ModelNode> xmlToModelOperations(String xml, String nameSpaceUriString, XMLElementReader<List<ModelNode>> parser) throws Exception {
    XMLMapper mapper = XMLMapper.Factory.create();
    mapper.registerRootElement(new QName(nameSpaceUriString, "subsystem"), parser);

    StringReader strReader = new StringReader(xml);

    XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(new StreamSource(strReader));
    List<ModelNode> newList = new ArrayList<ModelNode>();
    mapper.parseDocument(newList, reader);

    return newList;
}
 

@Override
public void initializeParsers(ExtensionParsingContext context) {
    context.setSubsystemXmlMapping(SUBSYSTEM_NAME, "urn:jboss:domain:test-extension:1.0", new XMLElementReader<List<ModelNode>>() {

        @Override
        public void readElement(XMLExtendedStreamReader reader, List<ModelNode> value) throws XMLStreamException {
        }
    });
}
 

/**
 * Parsers retain the namespace, but the local part becomes 'subsystem'
 *
 * @param factory the factory producing the parsers
 * @return
 */
public static Optional<Map<QName, XMLElementReader<List<ModelNode>>>> mapParserNamespaces(AbstractParserFactory factory) {
    Map<QName, XMLElementReader<List<ModelNode>>> result =
            factory.create().entrySet()
                    .stream()
                    .collect(Collectors.toMap(
                            e -> new QName(e.getKey().getNamespaceURI(), SUBSYSTEM),
                            e -> e.getValue()
                    ));

    return Optional.of(result);
}
 

@Override
public Map<QName, XMLElementReader<List<ModelNode>>> create() {
    ParsingContext ctx = new ParsingContext();
    UndertowExtension ext = new UndertowExtension();
    ext.initializeParsers(ctx);
    return ctx.getParser();
}
 

@Override
public Map<QName, XMLElementReader<List<ModelNode>>> create() {
    ParsingContext ctx = new ParsingContext();
    JcaExtension ext = new JcaExtension();
    ext.initializeParsers(ctx);
    return ctx.getParser();
}
 

@Override
public void setSubsystemXmlMapping(String subsystemName, String namespaceUri, XMLElementReader<List<ModelNode>> reader) {
    assert subsystemName != null : "subsystemName is null";
    assert namespaceUri != null : "namespaceUri is null";
    synchronized (extension) {
        extension.getSubsystemInfo(subsystemName).addParsingNamespace(namespaceUri);
        if (extension.xmlMapper != null) {
            extension.xmlMapper.registerRootElement(new QName(namespaceUri, SUBSYSTEM), reader);
            preCacheParserDescription(reader);
            hasNonSupplierParser = true;
        }
    }
}
 

@Override
public Map<QName, XMLElementReader<List<ModelNode>>> create() {
    ParsingContext ctx = new ParsingContext();
    RemotingExtension ext = new RemotingExtension();
    ext.initializeParsers(ctx);
    return ctx.getParser();
}
 

private void preCacheParserDescription(XMLElementReader<List<ModelNode>> reader) {
    if (ExtensionRegistry.this.processType != ProcessType.DOMAIN_SERVER
            && reader instanceof PersistentResourceXMLParser) {
        // In a standard WildFly boot this method is being called as part of concurrent
        // work on multiple extensions. Generating the PersistentResourceXMLDescription
        // used by PersistentResourceXMLParser involves a lot of classloading and static
        // field initialization that can benefit by being done as part of this concurrent
        // work instead of being deferred to the single-threaded parsing phase. So, we ask
        // the parser to generate and cache that description for later use during parsing.
        //noinspection deprecation
        ((PersistentResourceXMLParser) reader).cacheXMLDescription();
    }
}
 

public Map<QName, XMLElementReader<List<ModelNode>>> create() {

        ParsingContext ctx = new ParsingContext();
        LoggingExtension ext = new LoggingExtension();
        ext.initializeParsers(ctx);
        return ctx.getParser();
    }
 

@Override
public Map<QName, XMLElementReader<List<ModelNode>>> create() {
    ParsingContext ctx = new ParsingContext();
    NamingExtension ext = new NamingExtension();
    ext.initializeParsers(ctx);
    return ctx.getParser();
}
 

@Override
public Map<QName, XMLElementReader<List<ModelNode>>> create() {
    ParsingContext ctx = new ParsingContext();
    DataSourcesExtension ext = new DataSourcesExtension();
    ext.initializeParsers(ctx);
    return ctx.getParser();
}
 

/**
 * Construct a new instance.
 *
 * @param fileName the configuration base file name
 * @param rootElement the root element of the configuration file
 * @param rootParser the root model parser
 * @param rootDeparser the root model deparser
 */
public XmlConfigurationPersister(final File fileName, final QName rootElement, final XMLElementReader<List<ModelNode>> rootParser,
                                 final XMLElementWriter<ModelMarshallingContext> rootDeparser, final boolean suppressLoad) {
    super(rootDeparser);
    this.fileName = fileName;
    this.rootElement = rootElement;
    this.rootParser = rootParser;
    this.additionalParsers = new HashMap<QName, XMLElementReader<List<ModelNode>>>();
    this.suppressLoad = suppressLoad;
}
 

@Override
public Map<QName, XMLElementReader<List<ModelNode>>> create() {
    ParsingContext ctx = new ParsingContext();
    EeExtension ext = new EeExtension();
    ext.initializeParsers(ctx);
    return ctx.getParser();
}
 

private ExtensionRegistry cloneExtensionRegistry(AdditionalInitialization additionalInit) {
    final ExtensionRegistry clone = new ExtensionRegistry(additionalInit.getProcessType(), new RunningModeControl(additionalInit.getExtensionRegistryRunningMode()), null, null, null, RuntimeHostControllerInfoAccessor.SERVER);
    for (String extension : extensionParsingRegistry.getExtensionModuleNames()) {
        ExtensionParsingContext epc = clone.getExtensionParsingContext(extension, null);
        for (Map.Entry<String, SubsystemInformation> entry : extensionParsingRegistry.getAvailableSubsystems(extension).entrySet()) {
            for (String namespace : entry.getValue().getXMLNamespaces()) {
                epc.setSubsystemXmlMapping(entry.getKey(), namespace, (XMLElementReader) null);
            }
        }
    }

    return clone;
}
 

@Override
public Map<QName, XMLElementReader<List<ModelNode>>> create() {
    ParsingContext ctx = new ParsingContext();
    SecurityExtension ext = new SecurityExtension();
    ext.initializeParsers(ctx);
    return ctx.getParser();
}
 

default Optional<Map<QName, XMLElementReader<List<ModelNode>>>> getSubsystemParsers() throws Exception {
    return Optional.empty();
}
 

public TestParser(TestModelType type, XMLElementReader<List<ModelNode>> reader, XMLElementWriter<ModelMarshallingContext> writer) {
    this.type = type;
    this.reader = reader;
    this.writer = writer;
}
 

@Override
public Optional<Map<QName, XMLElementReader<List<ModelNode>>>> getSubsystemParsers() throws Exception {

    return AbstractParserFactory.mapParserNamespaces(new IOParserFactory());
}
 

public GitConfigurationPersister(GitRepository gitRepository, ConfigurationFile file, QName rootElement, XMLElementReader<List<ModelNode>> rootParser,
        XMLElementWriter<ModelMarshallingContext> rootDeparser) {
    this(gitRepository, file, rootElement, rootParser, rootDeparser, false);
}
 

public JBossAllXmlParserAdaptor(final XMLElementReader<ParseResult> elementReader) {
    this.elementReader = elementReader;
}
 

public void registerAdditionalRootElement(final QName anotherRoot, final XMLElementReader<List<ModelNode>> parser){
    synchronized (additionalParsers) {
        additionalParsers.put(anotherRoot, parser);
    }
}
 

private static void setParser(final ExtensionParsingContext context, final Namespace namespace, final XMLElementReader<List<ModelNode>> parser) {
    context.setSubsystemXmlMapping(SUBSYSTEM_NAME, namespace.getUriString(), parser);
}
 

BackupRemoteDomainXmlPersister(File file, File bootFile, QName rootElement, XMLElementReader<List<ModelNode>> rootParser, XMLElementWriter<ModelMarshallingContext> rootDeparser) {
    super(file, rootElement, rootParser, rootDeparser);
    this.bootWriter = new XmlConfigurationPersister(bootFile, rootElement, rootParser, rootDeparser);
    this.file = file;
    this.bootFile = bootFile;
}
 

@Override
public void registerAdditionalRootElement(final QName anotherRoot, final XMLElementReader<List<ModelNode>> parser){
    bootWriter.registerAdditionalRootElement(anotherRoot, parser);
    super.registerAdditionalRootElement(anotherRoot, parser);
}
 

public void registerAdditionalRootElement(final QName anotherRoot, final XMLElementReader<List<ModelNode>> parser){
    super.registerAdditionalRootElement(anotherRoot, parser);
}