/**
* Read an element which contains only a single string attribute.
*
* @param reader the reader
* @param attributeName the attribute name, usually "value" or "name"
* @return the string value
* @throws javax.xml.stream.XMLStreamException if an error occurs or if the element does not
* contain the specified attribute, contains other attributes, or contains child elements.
*/
public static String readStringAttributeElement(
final XMLExtendedStreamReader reader, final String attributeName) throws XMLStreamException {
requireSingleAttribute(reader, attributeName);
final String value = reader.getAttributeValue(0);
requireNoContent(reader);
return value;
}
/**
* Read an element which contains only a single boolean attribute.
*
* @param reader the reader
* @param attributeName the attribute name, usually "value"
* @return the boolean value
* @throws javax.xml.stream.XMLStreamException if an error occurs or if the element does not
* contain the specified attribute, contains other attributes, or contains child elements.
*/
public static boolean readBooleanAttributeElement(
final XMLExtendedStreamReader reader, final String attributeName) throws XMLStreamException {
requireSingleAttribute(reader, attributeName);
final boolean value = Boolean.parseBoolean(reader.getAttributeValue(0));
requireNoContent(reader);
return value;
}
private void parseStateTransfer(XMLExtendedStreamReader reader, ModelNode stateTransfer)
throws XMLStreamException {
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case ENABLED:
{
stateTransfer.get(ModelKeys.ENABLED).set(Boolean.parseBoolean(value));
break;
}
case TIMEOUT:
{
stateTransfer.get(ModelKeys.TIMEOUT).set(Long.parseLong(value));
break;
}
case FLUSH_TIMEOUT:
{
stateTransfer.get(ModelKeys.FLUSH_TIMEOUT).set(Long.parseLong(value));
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}
private void parseEviction(
XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
throws XMLStreamException {
PathAddress evictionAddress =
PathAddress.pathAddress(cache.get(OP_ADDR))
.append(ModelKeys.EVICTION, ModelKeys.EVICTION_NAME);
ModelNode eviction = Util.createAddOperation(evictionAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case STRATEGY:
{
EvictionResource.EVICTION_STRATEGY.parseAndSetParameter(value, eviction, reader);
break;
}
case MAX_ENTRIES:
{
EvictionResource.MAX_ENTRIES.parseAndSetParameter(value, eviction, reader);
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
operations.add(eviction);
}
private ModelNode parseJPA(XMLExtendedStreamReader reader) throws XMLStreamException {
String dataSourceName = null;
int count = reader.getAttributeCount();
for (int i = 0; i < count; i++) {
final String value = reader.getAttributeValue(i);
final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case DEFAULT_DATASOURCE_NAME:
{
dataSourceName = value;
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
// Require no content
ParseUtils.requireNoContent(reader);
if (dataSourceName == null) {
throw ParseUtils.missingRequired(
reader, Collections.singleton(Attribute.DEFAULT_DATASOURCE_NAME));
}
return createAddOperation(dataSourceName);
}
private void parseArchiveValidation(final XMLExtendedStreamReader reader, final ModelNode node)
throws XMLStreamException {
final int cnt = reader.getAttributeCount();
for (int i = 0; i < cnt; i++) {
final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case ENABLED:
{
node.get(ARCHIVE_VALIDATION_ENABLED)
.set(Boolean.parseBoolean(reader.getAttributeValue(i)));
break;
}
case FAIL_ON_ERROR:
{
node.get(ARCHIVE_VALIDATION_FAIL_ON_ERROR)
.set(Boolean.parseBoolean(reader.getAttributeValue(i)));
break;
}
case FAIL_ON_WARN:
{
node.get(ARCHIVE_VALIDATION_FAIL_ON_WARN)
.set(Boolean.parseBoolean(reader.getAttributeValue(i)));
break;
}
default:
{
throw unexpectedAttribute(reader, i);
}
}
}
// Handle elements
requireNoContent(reader);
}
/** {@inheritDoc} */
@Override
public void readElement(XMLExtendedStreamReader reader, List<ModelNode> list)
throws XMLStreamException {
// Require no content
ParseUtils.requireNoContent(reader);
list.add(createAddSubsystemOperation());
}
ModelNode parseModulesElement(XMLExtendedStreamReader reader) throws XMLStreamException {
// Handle attributes
requireNoAttributes(reader);
ModelNode modules = new ModelNode();
// Handle elements
while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
switch (Namespace.forUri(reader.getNamespaceURI())) {
case OSGI_1_0:
{
final Element element = Element.forName(reader.getLocalName());
if (element == Element.MODULE) {
String identifier = null;
String start = null;
final int count = reader.getAttributeCount();
for (int i = 0; i < count; i++) {
requireNoNamespaceAttribute(reader, i);
final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case IDENTIFIER:
{
identifier = reader.getAttributeValue(i);
break;
}
case START:
{
start = reader.getAttributeValue(i);
break;
}
default:
throw unexpectedAttribute(reader, i);
}
}
if (identifier == null)
throw missingRequired(reader, Collections.singleton(Attribute.IDENTIFIER));
if (modules.has(identifier))
throw new XMLStreamException(
element.getLocalName() + " already declared", reader.getLocation());
ModelNode module = new ModelNode();
if (start != null) {
module.get(START).set(start);
}
modules.get(identifier).set(module);
requireNoContent(reader);
} else {
throw unexpectedElement(reader);
}
break;
}
default:
throw unexpectedElement(reader);
}
}
return modules;
}
private void parseThreadPool(
ThreadPoolResourceDefinition pool,
XMLExtendedStreamReader reader,
PathAddress parentAddress,
Map<PathAddress, ModelNode> operations)
throws XMLStreamException {
PathAddress address = parentAddress.append(pool.getPathElement());
ModelNode operation = Util.createAddOperation(address);
operations.put(address, operation);
for (int i = 0; i < reader.getAttributeCount(); i++) {
XMLAttribute attribute = XMLAttribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case MIN_THREADS:
readAttribute(reader, i, operation, pool.getMinThreads());
break;
case MAX_THREADS:
readAttribute(reader, i, operation, pool.getMaxThreads());
break;
case QUEUE_LENGTH:
readAttribute(reader, i, operation, pool.getQueueLength());
break;
case KEEPALIVE_TIME:
readAttribute(reader, i, operation, pool.getKeepAliveTime());
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
}
private void parseRehashing(
XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the rehashing add operation
ModelNode rehashingAddress = cache.get(ModelDescriptionConstants.OP_ADDR).clone();
rehashingAddress.add(ModelKeys.STATE_TRANSFER, ModelKeys.STATE_TRANSFER_NAME);
rehashingAddress.protect();
ModelNode rehashing = Util.getEmptyOperation(ModelDescriptionConstants.ADD, rehashingAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case ENABLED:
{
CommonAttributes.ENABLED.parseAndSetParameter(value, rehashing, reader);
break;
}
case TIMEOUT:
{
CommonAttributes.TIMEOUT.parseAndSetParameter(value, rehashing, reader);
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
operations.add(rehashing);
}
private void parseEviction(XMLExtendedStreamReader reader, ModelNode eviction)
throws XMLStreamException {
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case STRATEGY:
{
try {
EvictionStrategy strategy = EvictionStrategy.valueOf(value);
eviction.get(ModelKeys.STRATEGY).set(strategy.name());
} catch (IllegalArgumentException e) {
throw ParseUtils.invalidAttributeValue(reader, i);
}
break;
}
case MAX_ENTRIES:
{
eviction.get(ModelKeys.MAX_ENTRIES).set(Integer.parseInt(value));
break;
}
case INTERVAL:
{
ROOT_LOGGER.deprecatedAttribute(
attribute.getLocalName(), Element.EVICTION.getLocalName(), "ISPN-1268");
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}
private void parseExpiration(XMLExtendedStreamReader reader, ModelNode expiration)
throws XMLStreamException {
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case MAX_IDLE:
{
expiration.get(ModelKeys.MAX_IDLE).set(Long.parseLong(value));
break;
}
case LIFESPAN:
{
expiration.get(ModelKeys.LIFESPAN).set(Long.parseLong(value));
break;
}
case INTERVAL:
{
expiration.get(ModelKeys.INTERVAL).set(Long.parseLong(value));
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}
/** {@inheritDoc} */
@Override
public void readElement(final XMLExtendedStreamReader reader, final List<ModelNode> list)
throws XMLStreamException {
// Require no attributes or content
requireNoAttributes(reader);
requireNoContent(reader);
list.add(Util.createAddOperation(PathAddress.pathAddress(PATH_SUBSYSTEM)));
}
/** {@inheritDoc} */
@Override
public void readElement(XMLExtendedStreamReader reader, List<ModelNode> list)
throws XMLStreamException {
ParseUtils.requireNoAttributes(reader);
ParseUtils.requireNoContent(reader);
list.add(createAddOperation());
}
/** Adds the worker thread pool attributes to the subysystem add method */
void parseWorkerThreadPool(final XMLExtendedStreamReader reader, final ModelNode subsystemAdd)
throws XMLStreamException {
final int count = reader.getAttributeCount();
for (int i = 0; i < count; i++) {
requireNoNamespaceAttribute(reader, i);
final String value = reader.getAttributeValue(i);
final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case WORKER_READ_THREADS:
if (subsystemAdd.hasDefined(CommonAttributes.WORKER_READ_THREADS)) {
throw duplicateAttribute(reader, CommonAttributes.WORKER_READ_THREADS);
}
RemotingSubsystemRootResource.WORKER_READ_THREADS.parseAndSetParameter(
value, subsystemAdd, reader);
break;
case WORKER_TASK_CORE_THREADS:
if (subsystemAdd.hasDefined(CommonAttributes.WORKER_TASK_CORE_THREADS)) {
throw duplicateAttribute(reader, CommonAttributes.WORKER_TASK_CORE_THREADS);
}
RemotingSubsystemRootResource.WORKER_TASK_CORE_THREADS.parseAndSetParameter(
value, subsystemAdd, reader);
break;
case WORKER_TASK_KEEPALIVE:
if (subsystemAdd.hasDefined(CommonAttributes.WORKER_TASK_KEEPALIVE)) {
throw duplicateAttribute(reader, CommonAttributes.WORKER_TASK_KEEPALIVE);
}
RemotingSubsystemRootResource.WORKER_TASK_KEEPALIVE.parseAndSetParameter(
value, subsystemAdd, reader);
break;
case WORKER_TASK_LIMIT:
if (subsystemAdd.hasDefined(CommonAttributes.WORKER_TASK_LIMIT)) {
throw duplicateAttribute(reader, CommonAttributes.WORKER_TASK_LIMIT);
}
RemotingSubsystemRootResource.WORKER_TASK_LIMIT.parseAndSetParameter(
value, subsystemAdd, reader);
break;
case WORKER_TASK_MAX_THREADS:
if (subsystemAdd.hasDefined(CommonAttributes.WORKER_TASK_MAX_THREADS)) {
throw duplicateAttribute(reader, CommonAttributes.WORKER_TASK_MAX_THREADS);
}
RemotingSubsystemRootResource.WORKER_TASK_MAX_THREADS.parseAndSetParameter(
value, subsystemAdd, reader);
break;
case WORKER_WRITE_THREADS:
if (subsystemAdd.hasDefined(CommonAttributes.WORKER_WRITE_THREADS)) {
throw duplicateAttribute(reader, CommonAttributes.WORKER_WRITE_THREADS);
}
RemotingSubsystemRootResource.WORKER_WRITE_THREADS.parseAndSetParameter(
value, subsystemAdd, reader);
break;
default:
throw unexpectedAttribute(reader, i);
}
}
requireNoContent(reader);
}
private void parseTransport(
XMLExtendedStreamReader reader, ModelNode containerAddress, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the transport add operation
ModelNode transport = Util.getEmptyOperation(ModelDescriptionConstants.ADD, null);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case STACK:
{
transport.get(ModelKeys.STACK).set(value);
break;
}
case EXECUTOR:
{
transport.get(ModelKeys.EXECUTOR).set(value);
break;
}
case LOCK_TIMEOUT:
{
transport.get(ModelKeys.LOCK_TIMEOUT).set(Long.parseLong(value));
break;
}
case SITE:
{
transport.get(ModelKeys.SITE).set(value);
break;
}
case RACK:
{
transport.get(ModelKeys.RACK).set(value);
break;
}
case MACHINE:
{
transport.get(ModelKeys.MACHINE).set(value);
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
// setup the transport address
ModelNode transportAddress = containerAddress.clone();
transportAddress.add(ModelKeys.SINGLETON, ModelKeys.TRANSPORT);
transportAddress.protect();
transport.get(ModelDescriptionConstants.OP_ADDR).set(transportAddress);
operations.add(transport);
}
/**
* Read an element which contains only a single list attribute of a given type.
*
* @param reader the reader
* @param attributeName the attribute name, usually "value"
* @param type the value type class
* @param <T> the value type
* @return the value list
* @throws javax.xml.stream.XMLStreamException if an error occurs or if the element does not
* contain the specified attribute, contains other attributes, or contains child elements.
*/
@SuppressWarnings({"unchecked"})
public static <T> List<T> readListAttributeElement(
final XMLExtendedStreamReader reader, final String attributeName, final Class<T> type)
throws XMLStreamException {
requireSingleAttribute(reader, attributeName);
// todo: fix this when this method signature is corrected
final List<T> value = (List<T>) reader.getListAttributeValue(0, type);
requireNoContent(reader);
return value;
}
static ModelNode parseSsl(XMLExtendedStreamReader reader) throws XMLStreamException {
final ModelNode ssl = new ModelNode();
ssl.setEmptyObject();
final int count = reader.getAttributeCount();
for (int i = 0; i < count; i++) {
requireNoNamespaceAttribute(reader, i);
final String value = reader.getAttributeValue(i);
final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case NAME:
ssl.get(NAME).set(value);
break;
case KEY_ALIAS:
ssl.get(KEY_ALIAS).set(value);
break;
case PASSWORD:
ssl.get(PASSWORD).set(value);
break;
case CERTIFICATE_KEY_FILE:
ssl.get(CERTIFICATE_KEY_FILE).set(value);
break;
case CIPHER_SUITE:
ssl.get(CIPHER_SUITE).set(value);
break;
case PROTOCOL:
ssl.get(PROTOCOL).set(value);
break;
case VERIFY_CLIENT:
ssl.get(VERIFY_CLIENT).set(value);
break;
case VERIFY_DEPTH:
ssl.get(VERIFY_DEPTH).set(Integer.valueOf(value));
break;
case CERTIFICATE_FILE:
ssl.get(CERTIFICATE_FILE).set(value);
break;
case CA_CERTIFICATE_FILE:
ssl.get(CA_CERTIFICATE_FILE).set(value);
break;
case CA_REVOCATION_URL:
ssl.get(CA_REVOCATION_URL).set(value);
break;
case SESSION_CACHE_SIZE:
ssl.get(SESSION_CACHE_SIZE).set(value);
break;
case SESSION_TIMEOUT:
ssl.get(SESSION_TIMEOUT).set(value);
break;
default:
throw unexpectedAttribute(reader, i);
}
}
requireNoContent(reader);
return ssl;
}
private void parseCcm(final XMLExtendedStreamReader reader, final ModelNode node)
throws XMLStreamException {
final boolean debug =
Boolean.parseBoolean(reader.getAttributeValue("", Attribute.DEBUG.getLocalName()));
final boolean error =
Boolean.parseBoolean(reader.getAttributeValue("", Attribute.ERROR.getLocalName()));
node.get(CACHED_CONNECTION_MANAGER_DEBUG).set(debug);
node.get(CACHED_CONNECTION_MANAGER_ERROR).set(error);
requireNoContent(reader);
}
private void parseBeanValidation(final XMLExtendedStreamReader reader, final ModelNode node)
throws XMLStreamException {
requireSingleAttribute(reader, Attribute.ENABLED.getLocalName());
final boolean value =
reader.getAttributeValue(0) != null
? Boolean.parseBoolean(reader.getAttributeValue(0))
: true;
requireNoContent(reader);
node.get(BEAN_VALIDATION_ENABLED).set(value);
// Don't add a requireNoContent here as readBooleanAttributeElement
// already performs that check.
}
@Override
public void parse(
final XMLExtendedStreamReader reader, PathAddress parentAddress, List<ModelNode> list)
throws XMLStreamException {
if (getXmlWrapperElement() != null) {
if (reader.getLocalName().equals(getXmlWrapperElement())) {
if (reader.hasNext()) {
if (reader.nextTag() == END_ELEMENT) {
return;
}
}
} else {
throw ParseUtils.unexpectedElement(reader);
}
}
boolean wildcard = getPathElement().isWildcard();
String name = null;
ModelNode op = Util.createAddOperation();
Map<String, AttributeDefinition> attributes = getAttributeMap();
for (int i = 0; i < reader.getAttributeCount(); i++) {
String attributeName = reader.getAttributeLocalName(i);
String value = reader.getAttributeValue(i);
if (wildcard && NAME.equals(attributeName)) {
name = value;
} else if (attributes.containsKey(attributeName)) {
AttributeDefinition def = attributes.get(attributeName);
if (def instanceof SimpleAttributeDefinition) {
((SimpleAttributeDefinition) def).parseAndSetParameter(value, op, reader);
} else if (def instanceof StringListAttributeDefinition) {
((StringListAttributeDefinition) def).parseAndSetParameter(value, op, reader);
} else {
throw new IllegalArgumentException("we should know how to handle " + def);
}
} else {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
if (wildcard && name == null) {
throw MESSAGES.missingRequiredAttributes(new StringBuilder(NAME), reader.getLocation());
}
PathElement path =
wildcard ? PathElement.pathElement(getPathElement().getKey(), name) : getPathElement();
PathAddress address = parentAddress.append(path);
op.get(ADDRESS).set(address.toModelNode());
list.add(op);
parseChildren(reader, address, list);
if (getXmlWrapperElement() != null) {
ParseUtils.requireNoContent(reader);
}
}
public void parse(final XMLExtendedStreamReader reader, final ModelNode operation)
throws XMLStreamException {
while (reader.hasNext() && reader.nextTag() != XMLStreamConstants.END_ELEMENT) {
if (reader.getLocalName().equals(getXmlName())) {
final String[] array =
requireAttributes(
reader,
org.jboss.as.controller.parsing.Attribute.NAME.getLocalName(),
org.jboss.as.controller.parsing.Attribute.VALUE.getLocalName());
parseAndAddParameterElement(array[0], array[1], operation, reader);
ParseUtils.requireNoContent(reader);
} else {
throw ParseUtils.unexpectedElement(reader);
}
}
}
private void parseTransport(
XMLExtendedStreamReader reader, ModelNode containerAddress, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the transport add operation
ModelNode transport = Util.getEmptyOperation(ModelDescriptionConstants.ADD, null);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case STACK:
{
TransportResource.STACK.parseAndSetParameter(value, transport, reader);
break;
}
case CLUSTER:
{
TransportResource.CLUSTER.parseAndSetParameter(value, transport, reader);
break;
}
case EXECUTOR:
{
TransportResource.EXECUTOR.parseAndSetParameter(value, transport, reader);
break;
}
case LOCK_TIMEOUT:
{
TransportResource.LOCK_TIMEOUT.parseAndSetParameter(value, transport, reader);
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
// setup the transport address
ModelNode transportAddress = containerAddress.clone();
transportAddress.add(ModelKeys.TRANSPORT, ModelKeys.TRANSPORT_NAME);
transportAddress.protect();
transport.get(ModelDescriptionConstants.OP_ADDR).set(transportAddress);
operations.add(transport);
}
public void parseChildren(
final XMLExtendedStreamReader reader, PathAddress parentAddress, List<ModelNode> list)
throws XMLStreamException {
if (getChildren().size() == 0) {
ParseUtils.requireNoContent(reader);
} else {
Map<String, PersistentResourceDefinition> children = getChildrenMap();
while (reader.hasNext() && reader.nextTag() != XMLStreamConstants.END_ELEMENT) {
PersistentResourceDefinition child = children.get(reader.getLocalName());
if (child != null) {
child.parse(reader, parentAddress, list);
} else {
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
private void parseStoreWriteBehind(
XMLExtendedStreamReader reader, ModelNode store, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the write-behind add operation
ModelNode writeBehindAddress = store.get(ModelDescriptionConstants.OP_ADDR).clone();
writeBehindAddress.add(ModelKeys.WRITE_BEHIND, ModelKeys.WRITE_BEHIND_NAME);
writeBehindAddress.protect();
ModelNode writeBehind =
Util.getEmptyOperation(ModelDescriptionConstants.ADD, writeBehindAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case FLUSH_LOCK_TIMEOUT:
{
StoreWriteBehindResource.FLUSH_LOCK_TIMEOUT.parseAndSetParameter(
value, writeBehind, reader);
break;
}
case MODIFICATION_QUEUE_SIZE:
{
StoreWriteBehindResource.MODIFICATION_QUEUE_SIZE.parseAndSetParameter(
value, writeBehind, reader);
break;
}
case SHUTDOWN_TIMEOUT:
{
StoreWriteBehindResource.SHUTDOWN_TIMEOUT.parseAndSetParameter(
value, writeBehind, reader);
break;
}
case THREAD_POOL_SIZE:
{
StoreWriteBehindResource.THREAD_POOL_SIZE.parseAndSetParameter(
value, writeBehind, reader);
break;
}
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
operations.add(writeBehind);
}
@SuppressWarnings("deprecation")
private void parseTransaction(
XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the transaction add operation
ModelNode transactionAddress = cache.get(ModelDescriptionConstants.OP_ADDR).clone();
transactionAddress.add(ModelKeys.TRANSACTION, ModelKeys.TRANSACTION_NAME);
transactionAddress.protect();
ModelNode transaction =
Util.getEmptyOperation(ModelDescriptionConstants.ADD, transactionAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case STOP_TIMEOUT:
{
CommonAttributes.STOP_TIMEOUT.parseAndSetParameter(value, transaction, reader);
break;
}
case MODE:
{
CommonAttributes.MODE.parseAndSetParameter(value, transaction, reader);
break;
}
case LOCKING:
{
CommonAttributes.LOCKING.parseAndSetParameter(value, transaction, reader);
break;
}
case EAGER_LOCKING:
{
ROOT_LOGGER.eagerAttributeDeprecated();
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
operations.add(transaction);
}
private void parseTransport(XMLExtendedStreamReader reader, ModelNode transport)
throws XMLStreamException {
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case STACK:
{
transport.get(ModelKeys.STACK).set(value);
break;
}
case EXECUTOR:
{
transport.get(ModelKeys.EXECUTOR).set(value);
break;
}
case LOCK_TIMEOUT:
{
transport.get(ModelKeys.LOCK_TIMEOUT).set(Long.parseLong(value));
break;
}
case SITE:
{
transport.get(ModelKeys.SITE).set(value);
break;
}
case RACK:
{
transport.get(ModelKeys.RACK).set(value);
break;
}
case MACHINE:
{
transport.get(ModelKeys.MACHINE).set(value);
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}
static ModelNode parseSimpleLoadProvider(XMLExtendedStreamReader reader)
throws XMLStreamException {
final ModelNode load = new ModelNode();
final int count = reader.getAttributeCount();
for (int i = 0; i < count; i++) {
requireNoNamespaceAttribute(reader, i);
final String value = reader.getAttributeValue(i);
final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case FACTOR:
load.get(FACTOR).set(value);
break;
default:
unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
return load;
}
static ModelNode parseContainerConfig(XMLExtendedStreamReader reader) throws XMLStreamException {
final ModelNode config = new ModelNode();
// no attributes
if (reader.getAttributeCount() > 0) {
throw unexpectedAttribute(reader, 0);
}
// elements
while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
final Element element = Element.forName(reader.getLocalName());
switch (element) {
case STATIC_RESOURCES:
{
final ModelNode resourceServing = parseStaticResources(reader);
config.get(STATIC_RESOURCES).set(resourceServing);
break;
}
case JSP_CONFIGURATION:
{
final ModelNode jspConfiguration = parseJSPConfiguration(reader);
config.get(JSP_CONFIGURATION).set(jspConfiguration);
break;
}
case MIME_MAPPING:
{
final String[] array =
requireAttributes(
reader, Attribute.NAME.getLocalName(), Attribute.VALUE.getLocalName());
config.get(MIME_MAPPING).get(array[0]).set(array[1]);
requireNoContent(reader);
break;
}
case WELCOME_FILE:
{
final String welcomeFile = reader.getElementText().trim();
config.get(WELCOME_FILE).add(welcomeFile);
break;
}
default:
throw unexpectedElement(reader);
}
}
return config;
}
private void parseRemoteServer(XMLExtendedStreamReader reader, ModelNode server)
throws XMLStreamException {
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case OUTBOUND_SOCKET_BINDING:
{
server.get(ModelKeys.OUTBOUND_SOCKET_BINDING).set(value);
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}