JAXRSubsystemRootResource() { super(JAXRExtension.SUBSYSTEM_PATH, JAXRExtension.getResolver(), CONNECTION_FACTORY_ATTRIBUTE, CONNECTION_FACTORY_IMPL_ATTRIBUTE); }
public String toString() { return getLocalName(); } }
@Override public void readElement(XMLExtendedStreamReader reader, List<ModelNode> operations) throws XMLStreamException { Namespace readerNS = Namespace.forUri(reader.getNamespaceURI()); switch (readerNS) { case JAXR_1_0: readElement1_0(reader, operations); break; case JAXR_1_1: readElement1_1(reader, operations); break; default: throw unexpectedElement(reader); } }
private void readElement1_1(XMLExtendedStreamReader reader, List<ModelNode> operations) throws XMLStreamException { final PathAddress address = PathAddress.pathAddress(JAXRExtension.SUBSYSTEM_PATH); final ModelNode addOp = Util.createAddOperation(address); operations.add(addOp); List<ModelNode> propertiesOps = null; while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { switch (Namespace.forUri(reader.getNamespaceURI())) { case JAXR_1_1: { final Element element = Element.forName(reader.getLocalName()); switch (element) { case CONNECTION_FACTORY: { parseBinding1_1(reader, addOp); break; } case PROPERTIES: { propertiesOps = parseProperties(reader, address); break; } default: throw unexpectedElement(reader); } } } } if (propertiesOps != null) { operations.addAll(propertiesOps); } }
private void readElement1_0(XMLExtendedStreamReader reader, List<ModelNode> operations) throws XMLStreamException { final PathAddress address = PathAddress.pathAddress(JAXRExtension.SUBSYSTEM_PATH); final ModelNode addOp = Util.createAddOperation(address); operations.add(addOp); List<ModelNode> propertiesOps = null; while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { switch (Namespace.forUri(reader.getNamespaceURI())) { case JAXR_1_0: { final Element element = Element.forName(reader.getLocalName()); switch (element) { case CONNECTION_FACTORY: { parseBinding1_0(reader, addOp); break; } case JUDDI_SERVER: { propertiesOps = parseJuddiServer(reader, address); break; } default: throw unexpectedElement(reader); } } } } if (propertiesOps != null) { operations.addAll(propertiesOps); } }
private List<ModelNode> parseProperties(XMLExtendedStreamReader reader, PathAddress address) throws XMLStreamException { requireNoAttributes(reader); List<ModelNode> result = new ArrayList<ModelNode>(); // Handle properties while (reader.hasNext() && reader.nextTag() != END_ELEMENT) { switch (Namespace.forUri(reader.getNamespaceURI())) { case JAXR_1_1: { final Element element = Element.forName(reader.getLocalName()); switch (element) { case PROPERTY: { ModelNode propNode = parseProperty(reader, address); result.add(propNode); break; } default: throw unexpectedElement(reader); } } } } return result; }
JAXRPropertyDefinition(JAXRConfiguration config) { super(JAXRExtension.PROPERTY_PATH, JAXRExtension.getResolver(ModelConstants.PROPERTY), new JAXRPropertyAdd(config), new JAXRPropertyRemove(config) ); this.config = config; }
@Override public void writeContent(XMLExtendedStreamWriter writer, SubsystemMarshallingContext context) throws XMLStreamException { context.startSubsystemElement(Namespace.CURRENT.getUriString(), false); ModelNode node = context.getModelNode(); // write connection-factory writer.writeStartElement(Element.CONNECTION_FACTORY.getLocalName()); JAXRSubsystemRootResource.CONNECTION_FACTORY_ATTRIBUTE.marshallAsAttribute(node, writer); JAXRSubsystemRootResource.CONNECTION_FACTORY_IMPL_ATTRIBUTE.marshallAsAttribute(node, writer); writer.writeEndElement(); ModelNode properties = node.get(ModelDescriptionConstants.PROPERTY); if (properties.isDefined()) { writer.writeStartElement(Element.PROPERTIES.getLocalName()); for (String key : properties.keys()) { writer.writeStartElement(Element.PROPERTY.getLocalName()); writer.writeAttribute(Attribute.NAME.getLocalName(), key); JAXRPropertyDefinition.VALUE.marshallAsAttribute(properties.get(key), writer); writer.writeEndElement(); } writer.writeEndElement(); } writer.writeEndElement(); }
JAXRSubsystemRootResource(JAXRConfiguration config) { super(JAXRExtension.SUBSYSTEM_PATH, JAXRExtension.getResolver(), new JAXRSubsystemAdd(config), ReloadRequiredRemoveStepHandler.INSTANCE ); this.config = config; }
@Override public void registerChildren(ManagementResourceRegistration subsystemRoot) { super.registerChildren(subsystemRoot); // JAXR Properties subsystemRoot.registerSubModel(new JAXRPropertyDefinition()); } }
@Override protected Set<ManagementResourceRegistration> initializeLegacyModel(ExtensionContext context) { SubsystemRegistration subsystemRegistration = context.registerSubsystem(SUBSYSTEM_NAME, CURRENT_MODEL_VERSION); subsystemRegistration.registerXMLElementWriter(JAXRSubsystemWriter.INSTANCE); ManagementResourceRegistration subsystemRoot = subsystemRegistration.registerSubsystemModel(new JAXRSubsystemRootResource()); return Collections.singleton(subsystemRoot); }
private ModelNode parseProperty(XMLExtendedStreamReader reader, PathAddress parent) throws XMLStreamException { // Handle attributes String name = null; String value = null; int count = reader.getAttributeCount(); for (int i = 0; i < count; i++) { requireNoNamespaceAttribute(reader, i); final String attrValue = reader.getAttributeValue(i); final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case NAME: { name = attrValue; break; } case VALUE: { value = attrValue; break; } default: throw unexpectedAttribute(reader, i); } } if (name == null) { throw missingRequired(reader, Collections.singleton(Attribute.NAME)); } if (value == null) { throw missingRequired(reader, Collections.singleton(Attribute.VALUE)); } requireNoContent(reader); final PathAddress address = parent.append(ModelDescriptionConstants.PROPERTY, name); ModelNode propNode = Util.createAddOperation(address); propNode.get(ModelDescriptionConstants.VALUE).set(value); return propNode; }
@Override protected boolean applyUpdateToRuntime(OperationContext context, ModelNode operation, String attributeName, ModelNode resolvedValue, ModelNode currentValue, HandbackHolder<Void> voidHandbackHolder) throws OperationFailedException { applyUpdateToConfig(config, attributeName, resolvedValue); return false; }
@Override protected void initializeLegacyParsers(ExtensionParsingContext context) { context.setSubsystemXmlMapping(SUBSYSTEM_NAME, Namespace.JAXR_1_1.getUriString(), JAXRSubsystemParser::new); context.setSubsystemXmlMapping(SUBSYSTEM_NAME, Namespace.JAXR_1_0.getUriString(), JAXRSubsystemParser::new); } }
@Override public void registerAttributes(final ManagementResourceRegistration registry) { JAXRWriteAttributeHandler writeHandler = new JAXRWriteAttributeHandler(config); registry.registerReadWriteAttribute(CONNECTION_FACTORY_ATTRIBUTE, null, writeHandler); registry.registerReadWriteAttribute(CONNECTION_FACTORY_IMPL_ATTRIBUTE, null, writeHandler); }
JAXRPropertyDefinition() { super(PathElement.pathElement(ModelDescriptionConstants.PROPERTY), JAXRExtension.getResolver(ModelDescriptionConstants.PROPERTY), VALUE); } }
private void parseBinding1_0(XMLExtendedStreamReader reader, ModelNode addOp) throws XMLStreamException { // Handle attributes String jndiName = null; int count = reader.getAttributeCount(); for (int i = 0; i < count; i++) { requireNoNamespaceAttribute(reader, i); final String attrValue = reader.getAttributeValue(i); final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case JNDI_NAME: { jndiName = attrValue; CONNECTION_FACTORY_ATTRIBUTE.parseAndSetParameter(jndiName, addOp, reader); break; } default: throw unexpectedAttribute(reader, i); } } if (jndiName == null) { throw missingRequired(reader, Collections.singleton(Attribute.JNDI_NAME)); } requireNoContent(reader); }
@Override protected void revertUpdateToRuntime(OperationContext context, ModelNode operation, String attributeName, ModelNode valueToRestore, ModelNode valueToRevert, Void handback) throws OperationFailedException { applyUpdateToConfig(config, attributeName, valueToRestore); }
private void parseBinding1_1(XMLExtendedStreamReader reader, ModelNode addOp) throws XMLStreamException { // Handle attributes String jndiName = null; int count = reader.getAttributeCount(); for (int i = 0; i < count; i++) { requireNoNamespaceAttribute(reader, i); final String attrValue = reader.getAttributeValue(i); final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case JNDI_NAME: { jndiName = attrValue; CONNECTION_FACTORY_ATTRIBUTE.parseAndSetParameter(jndiName, addOp, reader); break; } case CLASS: { CONNECTION_FACTORY_IMPL_ATTRIBUTE.parseAndSetParameter(attrValue, addOp, reader); break; } default: throw unexpectedAttribute(reader, i); } } if (jndiName == null) { throw missingRequired(reader, Collections.singleton(Attribute.JNDI_NAME)); } requireNoContent(reader); }
private List<ModelNode> parseJuddiServer(XMLExtendedStreamReader reader, PathAddress parent) throws XMLStreamException { List<ModelNode> result = new ArrayList<ModelNode>(); Set<Attribute> required = EnumSet.of(Attribute.PUBLISH_URL, Attribute.QUERY_URL); int count = reader.getAttributeCount(); for (int i = 0; i < count; i++) { requireNoNamespaceAttribute(reader, i); final String attrValue = reader.getAttributeValue(i); final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i)); required.remove(attribute); switch (attribute) { case PUBLISH_URL: { ModelNode propOp = Util.createAddOperation(parent.append(ModelDescriptionConstants.PROPERTY, "javax.xml.registry.lifeCycleManagerURL")); VALUE.parseAndSetParameter(attrValue, propOp, reader); result.add(propOp); break; } case QUERY_URL: { ModelNode propOp = Util.createAddOperation(parent.append(ModelDescriptionConstants.PROPERTY, "javax.xml.registry.queryManagerURL")); VALUE.parseAndSetParameter(attrValue, propOp, reader); result.add(propOp); break; } default: throw unexpectedAttribute(reader, i); } } if (required.size() > 0) { throw missingRequired(reader, required); } requireNoContent(reader); return result; }