private void parseCMs(XMLExtendedStreamReader reader, List<ModelNode> operations) throws XMLStreamException { while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final Element element = Element.forName(reader.getLocalName()); switch (element) { case CM_RESPOURCE: parseCM(reader, operations); break; default: { throw unexpectedElement(reader); } } } }
private void handleParam(XMLExtendedStreamReader reader, LoadableElements loadableElements) throws XMLStreamException { final Set<String> required = new HashSet<>(Arrays.asList(new String[]{TYPE})); for (int i = 0; i < reader.getAttributeCount(); ++i) { String attr = reader.getAttributeValue(i); String attrName = reader.getAttributeLocalName(i); required.remove(attrName); switch (attrName) { case TYPE: loadableElements.params.add(attr); break; default: throw ParseUtils.unexpectedAttribute(reader, i); } } if (!required.isEmpty()) { throw ParseUtils.missingRequired(reader, required); } while (reader.hasNext()) { switch (reader.nextTag()) { case END_ELEMENT: { return; } case START_ELEMENT: { throw ParseUtils.unexpectedElement(reader); } } } }
private void parseProtocol(XMLExtendedStreamReader reader, PathAddress stackAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { String type = require(reader, XMLAttribute.TYPE); PathAddress address = stackAddress.append(ProtocolResourceDefinition.pathElement(type)); ModelNode operation = Util.createAddOperation(address); operations.put(address, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { this.parseProtocolAttribute(reader, i, operation); } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseProtocolElement(reader, address, operations); } }
private void parseCMs(XMLExtendedStreamReader reader, List<ModelNode> operations) throws XMLStreamException { while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final Element element = Element.forName(reader.getLocalName()); switch (element) { case CM_RESPOURCE: parseCM(reader, operations); break; default: { throw unexpectedElement(reader); } } } }
private void parseLogin(XMLExtendedStreamReader reader, ModelNode operation) throws XMLStreamException { while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final String element = reader.getLocalName(); switch (element) { case LOGIN: { for (int i = 0; i < reader.getAttributeCount(); i++) { String att = reader.getAttributeLocalName(i); String value = reader.getAttributeValue(i); if (att.equals(MailSubsystemModel.USER_NAME)) { MailServerDefinition.USERNAME.parseAndSetParameter(value, operation, reader); } else if (att.equals(MailSubsystemModel.PASSWORD)) { PASSWORD.parseAndSetParameter(value, operation, reader); } } ParseUtils.requireNoContent(reader); break; } } } } }
private void parseInvalidationCache(XMLExtendedStreamReader reader, PathAddress containerAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { String name = require(reader, XMLAttribute.NAME); PathAddress address = containerAddress.append(InvalidationCacheResourceDefinition.pathElement(name)); ModelNode operation = Util.createAddOperation(address); operations.put(address, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { this.parseClusteredCacheAttribute(reader, i, address, operations); } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseCacheElement(reader, address, operations); } }
private void parsePlainAuthToken(XMLExtendedStreamReader reader, PathAddress protocolAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { PathAddress address = protocolAddress.append(PlainAuthTokenResourceDefinition.PATH); ModelNode operation = Util.createAddOperation(address); operations.put(protocolAddress.append(AuthTokenResourceDefinition.WILDCARD_PATH), operation); ParseUtils.requireNoAttributes(reader); while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseAuthTokenElement(reader, protocolAddress, operations); } require(reader, operation, AuthTokenResourceDefinition.Attribute.SHARED_SECRET); }
protected void parseChannelCreationOptions(final XMLExtendedStreamReader reader, final PathAddress address, final List<ModelNode> operations) throws XMLStreamException { while (reader.hasNext() && reader.nextTag() != XMLStreamConstants.END_ELEMENT) { switch (EJB3SubsystemXMLElement.forName(reader.getLocalName())) { case OPTION: { this.parseChannelCreationOption(reader, address, operations); break; } default: { throw unexpectedElement(reader); } } } }
private void parseStacks(XMLExtendedStreamReader reader, PathAddress address, Map<PathAddress, ModelNode> operations) throws XMLStreamException { ModelNode operation = operations.get(address); for (int i = 0; i < reader.getAttributeCount(); i++) { ParseUtils.requireNoNamespaceAttribute(reader, i); XMLAttribute attribute = XMLAttribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case DEFAULT: { readAttribute(reader, i, operation, JGroupsSubsystemResourceDefinition.Attribute.DEFAULT_STACK); break; } default: { throw ParseUtils.unexpectedAttribute(reader, i); } } } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { XMLElement element = XMLElement.forName(reader.getLocalName()); switch (element) { case STACK: { this.parseStack(reader, address, operations); break; } default: { throw ParseUtils.unexpectedElement(reader); } } } }
private void parseLocalCache(XMLExtendedStreamReader reader, PathAddress containerAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { String name = require(reader, XMLAttribute.NAME); PathAddress address = containerAddress.append(LocalCacheResourceDefinition.pathElement(name)); ModelNode operation = Util.createAddOperation(address); operations.put(address, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { this.parseCacheAttribute(reader, i, address, operations); } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseCacheElement(reader, address, operations); } }
private void parseLoginModules(XMLExtendedStreamReader reader, PathAddress parentAddress, List<ModelNode> list) throws XMLStreamException { while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final Element element = Element.forName(reader.getLocalName()); switch (element) { case LOGIN_MODULE: { EnumSet<Attribute> required = EnumSet.of(Attribute.CODE, Attribute.FLAG); EnumSet<Attribute> notAllowed = EnumSet.of(Attribute.TYPE, Attribute.LOGIN_MODULE_STACK_REF); parseCommonModule(reader, parentAddress, LOGIN_MODULE, required, notAllowed, list); break; } default: { throw unexpectedElement(reader); } } } }
private void parseChannels(XMLExtendedStreamReader reader, PathAddress address, Map<PathAddress, ModelNode> operations) throws XMLStreamException { ModelNode operation = operations.get(address); for (int i = 0; i < reader.getAttributeCount(); i++) { ParseUtils.requireNoNamespaceAttribute(reader, i); XMLAttribute attribute = XMLAttribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case DEFAULT: { readAttribute(reader, i, operation, JGroupsSubsystemResourceDefinition.Attribute.DEFAULT_CHANNEL); break; } default: { throw ParseUtils.unexpectedAttribute(reader, i); } } } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { XMLElement element = XMLElement.forName(reader.getLocalName()); switch (element) { case CHANNEL: { this.parseChannel(reader, address, operations); break; } default: { throw ParseUtils.unexpectedElement(reader); } } } }
private void parseReplicatedCache(XMLExtendedStreamReader reader, PathAddress containerAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { String name = require(reader, XMLAttribute.NAME); PathAddress address = containerAddress.append(ReplicatedCacheResourceDefinition.pathElement(name)); ModelNode operation = Util.createAddOperation(address); operations.put(address, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { this.parseClusteredCacheAttribute(reader, i, address, operations); } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseSharedStateCacheElement(reader, address, operations); } }
private void parseCaches(final XMLExtendedStreamReader reader, List<ModelNode> operations) throws XMLStreamException { // no attributes expected requireNoAttributes(reader); while (reader.hasNext() && reader.nextTag() != XMLStreamConstants.END_ELEMENT) { switch (EJB3SubsystemXMLElement.forName(reader.getLocalName())) { case CACHE: { this.parseCache(reader, operations); break; } default: { throw unexpectedElement(reader); } } } }
public void readElement(XMLExtendedStreamReader reader, List<ModelNode> list) throws XMLStreamException { if (reader.getAttributeCount() > 0) { throw unexpectedAttribute(reader, 0); subsystem.get(OP_ADDR).set(address); list.add(subsystem); final ModelNode logStoreAddress = address.clone(); final ModelNode logStoreOperation = new ModelNode(); list.add(logStoreOperation); choiceObjectStoreEncountered = false; needsDefaultRelativeTo = true; while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { if (Namespace.forUri(reader.getNamespaceURI()) != getExpectedNamespace()) { throw unexpectedElement(reader); final Element element = Element.forName(reader.getLocalName()); required.remove(element); if (!encountered.add(element)) { throw unexpectedElement(reader);
private void parseSocketProtocol(XMLExtendedStreamReader reader, PathAddress stackAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { String type = require(reader, XMLAttribute.TYPE); PathAddress address = stackAddress.append(ProtocolResourceDefinition.pathElement(type)); ModelNode operation = Util.createAddOperation(address); operations.put(address, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { this.parseSocketProtocolAttribute(reader, i, operation); } require(reader, operation, SocketBindingProtocolResourceDefinition.Attribute.SOCKET_BINDING); while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseProtocolElement(reader, address, operations); } }
private void parsePools(final XMLExtendedStreamReader reader, final List<ModelNode> operations) throws XMLStreamException { // no attributes expected requireNoAttributes(reader); while (reader.hasNext() && reader.nextTag() != XMLStreamConstants.END_ELEMENT) { switch (EJB3SubsystemXMLElement.forName(reader.getLocalName())) { case BEAN_INSTANCE_POOLS: { this.parseBeanInstancePools(reader, operations); break; } default: { throw unexpectedElement(reader); } } } }
if (reader.getAttributeCount() > 0) { throw unexpectedAttribute(reader, 0); while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { final Element element = Element.forName(reader.getLocalName()); switch (element) { case UUID: if (encountered) { throw unexpectedElement(reader); if (reader.getAttributeCount() > 0) { throw unexpectedAttribute(reader, 0); case SOCKET: { if (encountered) { throw unexpectedElement(reader); throw unexpectedElement(reader);
private void parseEncryptProtocol(XMLExtendedStreamReader reader, PathAddress stackAddress, Map<PathAddress, ModelNode> operations) throws XMLStreamException { String type = require(reader, XMLAttribute.TYPE); PathAddress address = stackAddress.append(ProtocolResourceDefinition.pathElement(type)); ModelNode operation = Util.createAddOperation(address); operations.put(address, operation); for (int i = 0; i < reader.getAttributeCount(); i++) { this.parseEncryptProtocolAttribute(reader, i, operation); } require(reader, operation, EncryptProtocolResourceDefinition.Attribute.KEY_ALIAS, EncryptProtocolResourceDefinition.Attribute.KEY_STORE); while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { this.parseEncryptProtocolElement(reader, address, operations); } }