private void parseCacheAttribute(
XMLExtendedStreamReader reader, int index, Attribute attribute, String value, ModelNode cache)
throws XMLStreamException {
switch (attribute) {
case NAME:
{
cache.get(ModelKeys.NAME).set(value);
break;
}
case START:
{
try {
StartMode mode = StartMode.valueOf(value);
cache.get(ModelKeys.START).set(mode.name());
} catch (IllegalArgumentException e) {
throw ParseUtils.invalidAttributeValue(reader, index);
}
break;
}
case BATCHING:
{
cache.get(ModelKeys.BATCHING).set(Boolean.parseBoolean(value));
break;
}
case INDEXING:
{
try {
Indexing indexing = Indexing.valueOf(value);
cache.get(ModelKeys.INDEXING).set(indexing.name());
} catch (IllegalArgumentException e) {
throw ParseUtils.invalidAttributeValue(reader, index);
}
break;
}
default:
{
throw ParseUtils.unexpectedAttribute(reader, index);
}
}
}
Collection<ServiceController<?>> installRuntimeServices(
OperationContext context,
ModelNode operation,
ModelNode containerModel,
ServiceVerificationHandler verificationHandler)
throws OperationFailedException {
final PathAddress address = getCacheContainerAddressFromOperation(operation);
final String name = address.getLastElement().getValue();
final ServiceTarget target = context.getServiceTarget();
// pick up the attribute values from the model
ModelNode resolvedValue = null;
// make default cache non required (AS7-3488)
final String defaultCache =
(resolvedValue =
CacheContainerResourceDefinition.DEFAULT_CACHE.resolveModelAttribute(
context, containerModel))
.isDefined()
? resolvedValue.asString()
: null;
final String jndiName =
(resolvedValue =
CacheContainerResourceDefinition.JNDI_NAME.resolveModelAttribute(
context, containerModel))
.isDefined()
? resolvedValue.asString()
: null;
final String listenerExecutor =
(resolvedValue =
CacheContainerResourceDefinition.LISTENER_EXECUTOR.resolveModelAttribute(
context, containerModel))
.isDefined()
? resolvedValue.asString()
: null;
final String evictionExecutor =
(resolvedValue =
CacheContainerResourceDefinition.EVICTION_EXECUTOR.resolveModelAttribute(
context, containerModel))
.isDefined()
? resolvedValue.asString()
: null;
final String replicationQueueExecutor =
(resolvedValue =
CacheContainerResourceDefinition.REPLICATION_QUEUE_EXECUTOR
.resolveModelAttribute(context, containerModel))
.isDefined()
? resolvedValue.asString()
: null;
final ServiceController.Mode initialMode =
StartMode.valueOf(
CacheContainerResourceDefinition.START
.resolveModelAttribute(context, containerModel)
.asString())
.getMode();
final boolean statistics =
CacheContainerResourceDefinition.STATISTICS_ENABLED
.resolveModelAttribute(context, containerModel)
.asBoolean();
ServiceName[] aliases = null;
if (containerModel.hasDefined(ModelKeys.ALIASES)) {
List<ModelNode> list = operation.get(ModelKeys.ALIASES).asList();
aliases = new ServiceName[list.size()];
for (int i = 0; i < list.size(); i++) {
aliases[i] = EmbeddedCacheManagerService.getServiceName(list.get(i).asString());
}
}
final ModuleIdentifier moduleId =
(resolvedValue =
CacheContainerResourceDefinition.MODULE.resolveModelAttribute(
context, containerModel))
.isDefined()
? ModuleIdentifier.fromString(resolvedValue.asString())
: null;
// if we have a transport defined, pick up the transport-related attributes and install a
// channel
final Transport transportConfig =
containerModel.hasDefined(ModelKeys.TRANSPORT)
&& containerModel.get(ModelKeys.TRANSPORT).hasDefined(ModelKeys.TRANSPORT_NAME)
? new Transport()
: null;
String stack = null;
String transportExecutor = null;
Collection<ServiceController<?>> controllers = new LinkedList<>();
if (transportConfig != null) {
ModelNode transport = containerModel.get(ModelKeys.TRANSPORT, ModelKeys.TRANSPORT_NAME);
stack =
(resolvedValue =
TransportResourceDefinition.STACK.resolveModelAttribute(context, transport))
.isDefined()
? resolvedValue.asString()
: null;
// if cluster is not defined, use the cache container name as the default
final String cluster =
(resolvedValue =
TransportResourceDefinition.CLUSTER.resolveModelAttribute(context, transport))
.isDefined()
? resolvedValue.asString()
: name;
long lockTimeout =
TransportResourceDefinition.LOCK_TIMEOUT
.resolveModelAttribute(context, transport)
.asLong();
transportExecutor =
(resolvedValue =
TransportResourceDefinition.EXECUTOR.resolveModelAttribute(
context, transport))
.isDefined()
? resolvedValue.asString()
: null;
// initialise the Transport
transportConfig.setClusterName(cluster);
transportConfig.setLockTimeout(lockTimeout);
controllers.addAll(
this.installChannelServices(target, name, cluster, stack, verificationHandler));
// register the protocol metrics by adding a step
ChannelInstanceResourceDefinition.addChannelProtocolMetricsRegistrationStep(
context, cluster, stack);
for (ChannelServiceProvider provider :
ServiceLoader.load(
ChannelServiceProvider.class, ChannelServiceProvider.class.getClassLoader())) {
log.debugf("Installing %s for channel %s", provider.getClass().getSimpleName(), cluster);
controllers.addAll(provider.install(target, name, moduleId));
}
}
// install the cache container configuration service
controllers.add(
this.installContainerConfigurationService(
target,
name,
defaultCache,
statistics,
moduleId,
stack,
transportConfig,
transportExecutor,
listenerExecutor,
evictionExecutor,
replicationQueueExecutor,
verificationHandler));
// install a cache container service
controllers.add(
this.installContainerService(
target, name, aliases, transportConfig, initialMode, verificationHandler));
// install a name service entry for the cache container
controllers.add(this.installJndiService(target, name, jndiName, verificationHandler));
controllers.add(
this.installKeyAffinityServiceFactoryService(target, name, verificationHandler));
controllers.add(
this.installGlobalComponentRegistryService(
target, name, transportConfig, verificationHandler));
log.debugf("%s cache container installed", name);
return controllers;
}
Collection<ServiceController<?>> installRuntimeServices(
OperationContext context,
ModelNode operation,
ModelNode containerModel,
ModelNode cacheModel,
ServiceVerificationHandler verificationHandler)
throws OperationFailedException {
// get all required addresses, names and service names
PathAddress cacheAddress = getCacheAddressFromOperation(operation);
PathAddress containerAddress = getCacheContainerAddressFromOperation(operation);
String cacheName = cacheAddress.getLastElement().getValue();
String containerName = containerAddress.getLastElement().getValue();
// get model attributes
ModelNode resolvedValue = null;
final String jndiName =
((resolvedValue = CommonAttributes.JNDI_NAME.resolveModelAttribute(context, cacheModel))
.isDefined())
? resolvedValue.asString()
: null;
final ServiceController.Mode initialMode =
StartMode.valueOf(
CommonAttributes.START.resolveModelAttribute(context, cacheModel).asString())
.getMode();
final ModuleIdentifier moduleId =
(resolvedValue = CommonAttributes.CACHE_MODULE.resolveModelAttribute(context, cacheModel))
.isDefined()
? ModuleIdentifier.fromString(resolvedValue.asString())
: null;
// create a list for dependencies which may need to be added during processing
List<Dependency<?>> dependencies = new LinkedList<Dependency<?>>();
// Infinispan Configuration to hold the operation data
ConfigurationBuilder builder =
new ConfigurationBuilder().read(getDefaultConfiguration(this.mode));
// process cache configuration ModelNode describing overrides to defaults
processModelNode(context, containerName, cacheModel, builder, dependencies);
// get container Model to pick up the value of the default cache of the container
// AS7-3488 make default-cache no required attribute
String defaultCache =
CommonAttributes.DEFAULT_CACHE.resolveModelAttribute(context, containerModel).asString();
ServiceTarget target = context.getServiceTarget();
Configuration config = builder.build();
Collection<ServiceController<?>> controllers = new ArrayList<ServiceController<?>>(3);
// install the cache configuration service (configures a cache)
controllers.add(
this.installCacheConfigurationService(
target,
containerName,
cacheName,
defaultCache,
moduleId,
builder,
config,
dependencies,
verificationHandler));
log.debugf(
"Cache configuration service for %s installed for container %s", cacheName, containerName);
// now install the corresponding cache service (starts a configured cache)
controllers.add(
this.installCacheService(
target,
containerName,
cacheName,
defaultCache,
initialMode,
config,
verificationHandler));
// install a name service entry for the cache
controllers.add(
this.installJndiService(target, containerName, cacheName, jndiName, verificationHandler));
log.debugf("Cache service for cache %s installed for container %s", cacheName, containerName);
return controllers;
}
@Override
protected void performRuntime(
OperationContext context,
ModelNode operation,
ModelNode model,
ServiceVerificationHandler verificationHandler,
List<ServiceController<?>> newControllers)
throws OperationFailedException {
// Because we use child resources in a read-only manner to configure the cache, replace the
// local model with the full model
model = Resource.Tools.readModel(context.readResource(PathAddress.EMPTY_ADDRESS));
// Configuration to hold the operation data
ConfigurationBuilder builder =
new ConfigurationBuilder().read(getDefaultConfiguration(this.mode));
// create a list for dependencies which may need to be added during processing
List<Dependency<?>> dependencies = new LinkedList<Dependency<?>>();
// process cache configuration ModelNode describing overrides to defaults
processModelNode(model, builder, dependencies);
// get all required addresses, names and service names
PathAddress cacheAddress = PathAddress.pathAddress(operation.get(OP_ADDR));
PathAddress containerAddress = cacheAddress.subAddress(0, cacheAddress.size() - 1);
String cacheName = cacheAddress.getLastElement().getValue();
String containerName = containerAddress.getLastElement().getValue();
ServiceName containerServiceName = EmbeddedCacheManagerService.getServiceName(containerName);
ServiceName cacheServiceName = containerServiceName.append(cacheName);
ServiceName cacheConfigurationServiceName =
CacheConfigurationService.getServiceName(containerName, cacheName);
// get container Model
Resource rootResource = context.getRootResource();
ModelNode container = rootResource.navigate(containerAddress).getModel();
// get default cache of the container and start mode
String defaultCache = container.require(ModelKeys.DEFAULT_CACHE).asString();
ServiceController.Mode initialMode =
model.hasDefined(ModelKeys.START)
? StartMode.valueOf(model.get(ModelKeys.START).asString()).getMode()
: ServiceController.Mode.ON_DEMAND;
// install the cache configuration service (configures a cache)
ServiceTarget target = context.getServiceTarget();
InjectedValue<EmbeddedCacheManager> containerInjection =
new InjectedValue<EmbeddedCacheManager>();
CacheConfigurationDependencies cacheConfigurationDependencies =
new CacheConfigurationDependencies(containerInjection);
CacheConfigurationService cacheConfigurationService =
new CacheConfigurationService(cacheName, builder, cacheConfigurationDependencies);
ServiceBuilder<Configuration> configBuilder =
target
.addService(cacheConfigurationServiceName, cacheConfigurationService)
.addDependency(containerServiceName, EmbeddedCacheManager.class, containerInjection)
.setInitialMode(ServiceController.Mode.PASSIVE);
Configuration config = builder.build();
if (config.invocationBatching().enabled()) {
cacheConfigurationDependencies
.getTransactionManagerInjector()
.inject(BatchModeTransactionManager.getInstance());
} else if (config.transaction().transactionMode()
== org.infinispan.transaction.TransactionMode.TRANSACTIONAL) {
configBuilder.addDependency(
TxnServices.JBOSS_TXN_TRANSACTION_MANAGER,
TransactionManager.class,
cacheConfigurationDependencies.getTransactionManagerInjector());
if (config.transaction().useSynchronization()) {
configBuilder.addDependency(
TxnServices.JBOSS_TXN_SYNCHRONIZATION_REGISTRY,
TransactionSynchronizationRegistry.class,
cacheConfigurationDependencies.getTransactionSynchronizationRegistryInjector());
}
}
// add in any additional dependencies resulting from ModelNode parsing
for (Dependency<?> dependency : dependencies) {
this.addDependency(configBuilder, dependency);
}
// add an alias for the default cache
if (cacheName.equals(defaultCache)) {
configBuilder.addAliases(CacheConfigurationService.getServiceName(containerName, null));
}
newControllers.add(configBuilder.install());
log.debugf(
"Cache configuration service for %s installed for container %s", cacheName, containerName);
// now install the corresponding cache service (starts a configured cache)
CacheDependencies cacheDependencies = new CacheDependencies(containerInjection);
CacheService<Object, Object> cacheService =
new CacheService<Object, Object>(cacheName, cacheDependencies);
ServiceBuilder<Cache<Object, Object>> cacheBuilder =
target
.addService(cacheServiceName, cacheService)
.addDependency(cacheConfigurationServiceName)
.setInitialMode(initialMode);
if (config.transaction().recovery().enabled()) {
cacheBuilder.addDependency(
TxnServices.JBOSS_TXN_ARJUNA_RECOVERY_MANAGER,
XAResourceRecoveryRegistry.class,
cacheDependencies.getRecoveryRegistryInjector());
}
// add an alias for the default cache
if (cacheName.equals(defaultCache)) {
cacheBuilder.addAliases(CacheService.getServiceName(containerName, null));
}
if (initialMode == ServiceController.Mode.ACTIVE) {
cacheBuilder.addListener(verificationHandler);
}
newControllers.add(cacheBuilder.install());
String jndiName =
(model.hasDefined(ModelKeys.JNDI_NAME)
? InfinispanJndiName.toJndiName(model.get(ModelKeys.JNDI_NAME).asString())
: InfinispanJndiName.defaultCacheJndiName(containerName, cacheName))
.getAbsoluteName();
ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName);
BinderService binder = new BinderService(bindInfo.getBindName());
@SuppressWarnings("rawtypes")
ServiceBuilder<ManagedReferenceFactory> binderBuilder =
target
.addService(bindInfo.getBinderServiceName(), binder)
.addAliases(ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(jndiName))
.addDependency(
cacheServiceName,
Cache.class,
new ManagedReferenceInjector<Cache>(binder.getManagedObjectInjector()))
.addDependency(
bindInfo.getParentContextServiceName(),
ServiceBasedNamingStore.class,
binder.getNamingStoreInjector())
.setInitialMode(ServiceController.Mode.PASSIVE);
newControllers.add(binderBuilder.install());
log.debugf("Cache service for cache %s installed for container %s", cacheName, containerName);
}
