private void parseIndexing(XMLExtendedStreamReader reader, ModelNode node)
throws XMLStreamException {
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
if (attribute == Attribute.INDEX) {
CacheResource.INDEXING.parseAndSetParameter(value, node, reader);
} else {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case PROPERTY:
{
int attributes = reader.getAttributeCount();
String property = null;
for (int i = 0; i < attributes; i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case NAME:
{
property = value;
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (property == null) {
throw ParseUtils.missingRequired(reader, Collections.singleton(Attribute.NAME));
}
String value = reader.getElementText();
CacheResource.INDEXING_PROPERTIES.parseAndAddParameterElement(
property, value, node, reader);
break;
}
default:
{
throw ParseUtils.unexpectedElement(reader);
}
}
}
// ParseUtils.requireNoContent(reader);
}
private void parseCustomStore(
XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the store add operation
ModelNode storeAddress = cache.get(ModelDescriptionConstants.OP_ADDR).clone();
storeAddress.add(ModelKeys.STORE, ModelKeys.STORE_NAME);
storeAddress.protect();
ModelNode store = Util.getEmptyOperation(ModelDescriptionConstants.ADD, storeAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case CLASS:
{
CommonAttributes.CLASS.parseAndSetParameter(value, store, reader);
break;
}
default:
{
this.parseStoreAttribute(reader, i, attribute, value, store);
}
}
}
if (!store.hasDefined(ModelKeys.CLASS)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.CLASS));
}
this.parseStoreProperties(reader, store);
operations.add(store);
}
private void parseCustomStore(
XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
throws XMLStreamException {
PathAddress storeAddress =
PathAddress.pathAddress(cache.get(OP_ADDR)).append(ModelKeys.STORE, ModelKeys.STORE_NAME);
ModelNode store = Util.createAddOperation(storeAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case CLASS:
{
StoreResource.CLASS.parseAndSetParameter(value, store, reader);
break;
}
default:
{
this.parseStoreAttribute(reader, i, attribute, value, store);
}
}
}
if (!store.hasDefined(ModelKeys.CLASS)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.CLASS));
}
List<ModelNode> additionalConfigurationOperations = new ArrayList<ModelNode>();
this.parseStoreElements(reader, store, additionalConfigurationOperations);
operations.add(store);
operations.addAll(additionalConfigurationOperations);
}
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 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 parseLocalCache(
XMLExtendedStreamReader reader, ModelNode containerAddress, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the cache add operation
ModelNode cache = Util.getEmptyOperation(ModelDescriptionConstants.ADD, null);
List<ModelNode> additionalConfigurationOperations = new ArrayList<ModelNode>();
// set the cache mode to local
// cache.get(ModelKeys.MODE).set(Configuration.CacheMode.LOCAL.name());
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
this.parseCacheAttribute(reader, i, attribute, value, cache);
}
if (!cache.hasDefined(ModelKeys.NAME)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.NAME));
}
// update the cache address with the cache name
addCacheNameToAddress(cache, containerAddress, ModelKeys.LOCAL_CACHE);
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
this.parseCacheElement(reader, element, cache, additionalConfigurationOperations);
}
operations.add(cache);
// add operations to create configuration resources
for (ModelNode additionalOperation : additionalConfigurationOperations) {
operations.add(additionalOperation);
}
}
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 parseReplicatedCache(XMLExtendedStreamReader reader, ModelNode cache)
throws XMLStreamException {
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
this.parseClusteredCacheAttribute(
reader, i, attribute, value, cache, Configuration.CacheMode.REPL_SYNC);
}
if (!cache.hasDefined(ModelKeys.NAME)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.NAME));
}
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case STATE_TRANSFER:
{
this.parseStateTransfer(reader, cache.get(ModelKeys.STATE_TRANSFER).setEmptyObject());
break;
}
default:
{
this.parseCacheElement(reader, element, cache);
}
}
}
}
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);
}
private void parseFileStore(XMLExtendedStreamReader reader, ModelNode store)
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 RELATIVE_TO:
{
store.get(ModelKeys.RELATIVE_TO).set(value);
break;
}
case PATH:
{
store.get(ModelKeys.PATH).set(value);
break;
}
default:
{
this.parseStoreAttribute(reader, i, attribute, value, store);
}
}
}
this.parseStoreProperties(reader, store);
}
private void parseFileStore(
XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the store add operation
ModelNode storeAddress = cache.get(ModelDescriptionConstants.OP_ADDR).clone();
storeAddress.add(ModelKeys.FILE_STORE, ModelKeys.FILE_STORE_NAME);
storeAddress.protect();
ModelNode store = Util.getEmptyOperation(ModelDescriptionConstants.ADD, storeAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case RELATIVE_TO:
{
CommonAttributes.RELATIVE_TO.parseAndSetParameter(value, store, reader);
break;
}
case PATH:
{
CommonAttributes.PATH.parseAndSetParameter(value, store, reader);
break;
}
default:
{
this.parseStoreAttribute(reader, i, attribute, value, store);
}
}
}
this.parseStoreProperties(reader, store);
operations.add(store);
}
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);
}
/**
* {@inheritDoc}
*
* @see
* org.jboss.staxmapper.XMLElementReader#readElement(org.jboss.staxmapper.XMLExtendedStreamReader,
* java.lang.Object)
*/
@Override
public void readElement(XMLExtendedStreamReader reader, List<ModelNode> operations)
throws XMLStreamException {
ModelNode subsystemAddress = new ModelNode();
subsystemAddress.add(ModelDescriptionConstants.SUBSYSTEM, InfinispanExtension.SUBSYSTEM_NAME);
subsystemAddress.protect();
ModelNode subsystem = Util.getEmptyOperation(ModelDescriptionConstants.ADD, subsystemAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case DEFAULT_CACHE_CONTAINER:
{
subsystem.get(ModelKeys.DEFAULT_CACHE_CONTAINER).set(value);
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (!subsystem.hasDefined(ModelKeys.DEFAULT_CACHE_CONTAINER)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.DEFAULT_CACHE_CONTAINER));
}
// command to add the subsystem
operations.add(subsystem);
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
switch (Namespace.forUri(reader.getNamespaceURI())) {
case INFINISPAN_1_0:
case INFINISPAN_1_1:
{
Element element = Element.forName(reader.getLocalName());
switch (element) {
case CACHE_CONTAINER:
{
parseContainer(reader, subsystemAddress, operations);
break;
}
default:
{
throw ParseUtils.unexpectedElement(reader);
}
}
break;
}
default:
{
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
private void parseFileStore(
XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
throws XMLStreamException {
PathAddress storeAddress =
PathAddress.pathAddress(cache.get(OP_ADDR))
.append(ModelKeys.FILE_STORE, ModelKeys.FILE_STORE_NAME);
ModelNode store = Util.createAddOperation(storeAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case RELATIVE_TO:
{
FileStoreResource.RELATIVE_TO.parseAndSetParameter(value, store, reader);
break;
}
case PATH:
{
FileStoreResource.PATH.parseAndSetParameter(value, store, reader);
break;
}
default:
{
this.parseStoreAttribute(reader, i, attribute, value, store);
}
}
}
List<ModelNode> additionalConfigurationOperations = new ArrayList<ModelNode>();
this.parseStoreElements(reader, store, additionalConfigurationOperations);
operations.add(store);
operations.addAll(additionalConfigurationOperations);
}
private void parseStoreProperty(
XMLExtendedStreamReader reader, ModelNode node, final List<ModelNode> operations)
throws XMLStreamException {
int attributes = reader.getAttributeCount();
String propertyName = null;
for (int i = 0; i < attributes; i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case NAME:
{
propertyName = value;
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (propertyName == null) {
throw ParseUtils.missingRequired(reader, Collections.singleton(Attribute.NAME));
}
String propertyValue = reader.getElementText();
PathAddress propertyAddress =
PathAddress.pathAddress(node.get(OP_ADDR)).append(ModelKeys.PROPERTY, propertyName);
ModelNode property = Util.createAddOperation(propertyAddress);
// represent the value as a ModelNode to cater for expressions
StorePropertyResource.VALUE.parseAndSetParameter(propertyValue, property, reader);
operations.add(property);
}
private void parseStoreProperty(XMLExtendedStreamReader reader, ModelNode node)
throws XMLStreamException {
int attributes = reader.getAttributeCount();
String property = null;
for (int i = 0; i < attributes; i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case NAME:
{
property = value;
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (property == null) {
throw ParseUtils.missingRequired(reader, Collections.singleton(Attribute.NAME));
}
String value = reader.getElementText();
node.get(ModelKeys.PROPERTIES).add(property, value);
}
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);
}
private void parseRemoteStore(
XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the store add operation
ModelNode storeAddress = cache.get(ModelDescriptionConstants.OP_ADDR).clone();
storeAddress.add(ModelKeys.REMOTE_STORE, ModelKeys.REMOTE_STORE_NAME);
storeAddress.protect();
ModelNode store = Util.getEmptyOperation(ModelDescriptionConstants.ADD, storeAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case CACHE:
{
CommonAttributes.CACHE.parseAndSetParameter(value, store, reader);
break;
}
case SOCKET_TIMEOUT:
{
CommonAttributes.SOCKET_TIMEOUT.parseAndSetParameter(value, store, reader);
break;
}
case TCP_NO_DELAY:
{
CommonAttributes.TCP_NO_DELAY.parseAndSetParameter(value, store, reader);
break;
}
default:
{
this.parseStoreAttribute(reader, i, attribute, value, store);
}
}
}
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case REMOTE_SERVER:
{
this.parseRemoteServer(reader, store.get(ModelKeys.REMOTE_SERVERS).add());
break;
}
default:
{
this.parseStoreProperty(reader, store);
}
}
}
if (!store.hasDefined(ModelKeys.REMOTE_SERVERS)) {
throw ParseUtils.missingRequired(reader, Collections.singleton(Element.REMOTE_SERVER));
}
operations.add(store);
}
private void parseJDBCStoreTable(XMLExtendedStreamReader reader, ModelNode table)
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 PREFIX:
{
table.get(ModelKeys.PREFIX).set(value);
break;
}
case FETCH_SIZE:
{
table.get(ModelKeys.FETCH_SIZE).set(Integer.parseInt(value));
break;
}
case BATCH_SIZE:
{
table.get(ModelKeys.BATCH_SIZE).set(Integer.parseInt(value));
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case ID_COLUMN:
{
this.parseJDBCStoreColumn(reader, table.get(ModelKeys.ID_COLUMN).setEmptyObject());
break;
}
case DATA_COLUMN:
{
this.parseJDBCStoreColumn(reader, table.get(ModelKeys.DATA_COLUMN).setEmptyObject());
break;
}
case TIMESTAMP_COLUMN:
{
this.parseJDBCStoreColumn(
reader, table.get(ModelKeys.TIMESTAMP_COLUMN).setEmptyObject());
break;
}
default:
{
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
private void parseBinaryKeyedJDBCStore(
XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations)
throws XMLStreamException {
PathAddress storeAddress =
PathAddress.pathAddress(cache.get(OP_ADDR))
.append(ModelKeys.BINARY_KEYED_JDBC_STORE, ModelKeys.BINARY_KEYED_JDBC_STORE_NAME);
ModelNode store = Util.createAddOperation(storeAddress);
List<ModelNode> additionalConfigurationOperations = new ArrayList<ModelNode>();
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case DATASOURCE:
{
BaseJDBCStoreResource.DATA_SOURCE.parseAndSetParameter(value, store, reader);
break;
}
default:
{
this.parseStoreAttribute(reader, i, attribute, value, store);
}
}
}
if (!store.hasDefined(ModelKeys.DATASOURCE)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.DATASOURCE));
}
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case BINARY_KEYED_TABLE:
{
this.parseJDBCStoreTable(
reader, store.get(ModelKeys.BINARY_KEYED_TABLE).setEmptyObject());
break;
}
case WRITE_BEHIND:
{
parseStoreWriteBehind(reader, store, additionalConfigurationOperations);
break;
}
default:
{
this.parseStoreProperty(reader, store, additionalConfigurationOperations);
}
}
}
operations.add(store);
operations.addAll(additionalConfigurationOperations);
}
private void parseDistributedCache(XMLExtendedStreamReader reader, ModelNode cache)
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 OWNERS:
{
cache.get(ModelKeys.OWNERS).set(Integer.parseInt(value));
break;
}
case VIRTUAL_NODES:
{
cache.get(ModelKeys.VIRTUAL_NODES).set(Integer.parseInt(value));
break;
}
case L1_LIFESPAN:
{
cache.get(ModelKeys.L1_LIFESPAN).set(Long.parseLong(value));
break;
}
default:
{
this.parseClusteredCacheAttribute(
reader, i, attribute, value, cache, Configuration.CacheMode.DIST_SYNC);
}
}
}
if (!cache.hasDefined(ModelKeys.NAME)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.NAME));
}
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case REHASHING:
{
this.parseRehashing(reader, cache.get(ModelKeys.REHASHING).setEmptyObject());
break;
}
default:
{
this.parseCacheElement(reader, element, cache);
}
}
}
}
private void parseRemoteStore(XMLExtendedStreamReader reader, ModelNode store)
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 CACHE:
{
store.get(ModelKeys.CACHE).set(value);
break;
}
case SOCKET_TIMEOUT:
{
store.get(ModelKeys.SOCKET_TIMEOUT).set(Long.parseLong(value));
break;
}
case TCP_NO_DELAY:
{
store.get(ModelKeys.TCP_NO_DELAY).set(Boolean.valueOf(value));
break;
}
default:
{
this.parseStoreAttribute(reader, i, attribute, value, store);
}
}
}
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case REMOTE_SERVER:
{
this.parseRemoteServer(reader, store.get(ModelKeys.REMOTE_SERVER).add());
break;
}
default:
{
this.parseStoreProperty(reader, store);
}
}
}
if (!store.hasDefined(ModelKeys.REMOTE_SERVER)) {
throw ParseUtils.missingRequired(reader, Collections.singleton(Element.REMOTE_SERVER));
}
}
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);
}
private void parseInvalidationCache(
XMLExtendedStreamReader reader, ModelNode containerAddress, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the cache add operation
ModelNode cache = 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));
this.parseClusteredCacheAttribute(reader, i, attribute, value, cache);
}
if (!cache.hasDefined(ModelKeys.NAME)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.NAME));
}
if (!cache.hasDefined(ModelKeys.MODE)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.MODE));
}
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case STATE_TRANSFER:
{
this.parseStateTransfer(reader, cache.get(ModelKeys.STATE_TRANSFER).setEmptyObject());
break;
}
default:
{
this.parseCacheElement(reader, element, cache);
}
}
}
String name = cache.get(ModelKeys.NAME).asString();
// setup the cache address
ModelNode cacheAddress = containerAddress.clone();
cacheAddress.add(ModelKeys.INVALIDATION_CACHE, name);
cacheAddress.protect();
cache.get(ModelDescriptionConstants.OP_ADDR).set(cacheAddress);
// get rid of NAME now that we are finished with it
cache.remove(ModelKeys.NAME);
operations.add(cache);
}
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);
}
/**
* {@inheritDoc}
*
* @see
* org.jboss.staxmapper.XMLElementReader#readElement(org.jboss.staxmapper.XMLExtendedStreamReader,
* java.lang.Object)
*/
@SuppressWarnings("deprecation")
@Override
public void readElement(XMLExtendedStreamReader reader, List<ModelNode> operations)
throws XMLStreamException {
ModelNode subsystemAddress = new ModelNode();
subsystemAddress.add(ModelDescriptionConstants.SUBSYSTEM, InfinispanExtension.SUBSYSTEM_NAME);
subsystemAddress.protect();
ModelNode subsystem = Util.getEmptyOperation(ModelDescriptionConstants.ADD, subsystemAddress);
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
case DEFAULT_CACHE_CONTAINER:
{
// Ignore
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
// command to add the subsystem
operations.add(subsystem);
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case CACHE_CONTAINER:
{
parseContainer(reader, subsystemAddress, operations);
break;
}
default:
{
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
@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 parseReplicatedCache(
XMLExtendedStreamReader reader, PathAddress containerAddress, List<ModelNode> operations)
throws XMLStreamException {
// ModelNode for the cache add operation
ModelNode cache = Util.getEmptyOperation(ModelDescriptionConstants.ADD, null);
List<ModelNode> additionalConfigurationOperations = new ArrayList<ModelNode>();
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
this.parseClusteredCacheAttribute(reader, i, attribute, value, cache);
}
if (!cache.hasDefined(ModelKeys.NAME)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.NAME));
}
if (!cache.hasDefined(ModelKeys.MODE)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.MODE));
}
// update the cache address with the cache name
addCacheNameToAddress(cache, containerAddress, ModelKeys.REPLICATED_CACHE);
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case STATE_TRANSFER:
{
this.parseStateTransfer(reader, cache, additionalConfigurationOperations);
break;
}
default:
{
this.parseCacheElement(reader, element, cache, additionalConfigurationOperations);
}
}
}
operations.add(cache);
// add operations to create configuration resources
for (ModelNode additionalOperation : additionalConfigurationOperations) {
operations.add(additionalOperation);
}
}
private void parseInvalidationCache(XMLExtendedStreamReader reader, ModelNode cache)
throws XMLStreamException {
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
this.parseClusteredCacheAttribute(
reader, i, attribute, value, cache, Configuration.CacheMode.INVALIDATION_SYNC);
}
if (!cache.hasDefined(ModelKeys.NAME)) {
throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.NAME));
}
while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) {
Element element = Element.forName(reader.getLocalName());
this.parseCacheElement(reader, element, cache);
}
}
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);
}
