@SuppressWarnings("rawtypes")
ServiceController<?> installJndiService(
ServiceTarget target,
String containerName,
String cacheName,
String jndiNameString,
ServiceVerificationHandler verificationHandler) {
final String jndiName =
InfinispanJndiName.createCacheJndiNameOrDefault(jndiNameString, containerName, cacheName);
final ServiceName cacheServiceName = CacheService.getServiceName(containerName, cacheName);
final ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName);
final BinderService binder = new BinderService(bindInfo.getBindName());
return 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)
.install();
}
void removeRuntimeServices(OperationContext context, ModelNode operation, ModelNode model)
throws OperationFailedException {
// get container and cache addresses
final PathAddress cacheAddress = getCacheAddressFromOperation(operation);
final PathAddress containerAddress = getCacheContainerAddressFromOperation(operation);
// get container and cache names
final String cacheName = cacheAddress.getLastElement().getValue();
final String containerName = containerAddress.getLastElement().getValue();
// remove all services started by CacheAdd, in reverse order
// remove the binder service
ModelNode resolvedValue = null;
final String jndiNameString =
(resolvedValue = CommonAttributes.JNDI_NAME.resolveModelAttribute(context, model))
.isDefined()
? resolvedValue.asString()
: null;
final String jndiName =
InfinispanJndiName.createCacheJndiNameOrDefault(jndiNameString, containerName, cacheName);
ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName);
context.removeService(bindInfo.getBinderServiceName());
// remove the CacheService instance
context.removeService(CacheService.getServiceName(containerName, cacheName));
// remove the cache configuration service
context.removeService(CacheConfigurationService.getServiceName(containerName, cacheName));
log.debugf("cache %s removed for container %s", cacheName, containerName);
}
@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 container,
// replace the local model with the full model
model = Resource.Tools.readModel(context.readResource(PathAddress.EMPTY_ADDRESS));
final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR));
final String name = address.getLastElement().getValue();
String defaultCache = model.require(ModelKeys.DEFAULT_CACHE).asString();
boolean hasTransport =
model.hasDefined(ModelKeys.TRANSPORT)
&& model.get(ModelKeys.TRANSPORT).hasDefined(ModelKeys.TRANSPORT_NAME);
Transport transportConfig = hasTransport ? new Transport() : null;
EmbeddedCacheManagerDependencies dependencies =
new EmbeddedCacheManagerDependencies(transportConfig);
ServiceName[] aliases = null;
if (model.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());
}
}
ServiceTarget target = context.getServiceTarget();
ServiceName serviceName = EmbeddedCacheManagerService.getServiceName(name);
ServiceBuilder<EmbeddedCacheManager> containerBuilder =
target
.addService(
serviceName, new EmbeddedCacheManagerService(name, defaultCache, dependencies))
.addDependency(
DependencyType.OPTIONAL,
ServiceName.JBOSS.append("mbean", "server"),
MBeanServer.class,
dependencies.getMBeanServerInjector())
.addAliases(aliases)
.setInitialMode(ServiceController.Mode.ON_DEMAND);
String jndiName =
(model.hasDefined(ModelKeys.JNDI_NAME)
? InfinispanJndiName.toJndiName(model.get(ModelKeys.JNDI_NAME).asString())
: InfinispanJndiName.defaultCacheContainerJndiName(name))
.getAbsoluteName();
ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName);
BinderService binder = new BinderService(bindInfo.getBindName());
ServiceBuilder<ManagedReferenceFactory> binderBuilder =
target
.addService(bindInfo.getBinderServiceName(), binder)
.addAliases(ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(jndiName))
.addDependency(
serviceName,
CacheContainer.class,
new ManagedReferenceInjector<CacheContainer>(binder.getManagedObjectInjector()))
.addDependency(
bindInfo.getParentContextServiceName(),
ServiceBasedNamingStore.class,
binder.getNamingStoreInjector())
.setInitialMode(ServiceController.Mode.ON_DEMAND);
newControllers.add(binderBuilder.install());
if (hasTransport) {
String stack = null;
ModelNode transport = model.get(ModelKeys.TRANSPORT, ModelKeys.TRANSPORT_NAME);
if (transport.hasDefined(ModelKeys.STACK)) {
stack = transport.get(ModelKeys.STACK).asString();
}
if (transport.hasDefined(ModelKeys.LOCK_TIMEOUT)) {
transportConfig.setLockTimeout(transport.get(ModelKeys.LOCK_TIMEOUT).asLong());
}
addExecutorDependency(
containerBuilder, transport, ModelKeys.EXECUTOR, transportConfig.getExecutorInjector());
ServiceName channelServiceName = ChannelService.getServiceName(name);
containerBuilder.addDependency(
channelServiceName, Channel.class, transportConfig.getChannelInjector());
InjectedValue<ChannelFactory> channelFactory = new InjectedValue<ChannelFactory>();
ServiceBuilder<Channel> channelBuilder =
target
.addService(channelServiceName, new ChannelService(name, channelFactory))
.addDependency(
ChannelFactoryService.getServiceName(stack), ChannelFactory.class, channelFactory)
.setInitialMode(ServiceController.Mode.ON_DEMAND);
newControllers.add(channelBuilder.install());
}
addExecutorDependency(
containerBuilder,
model,
ModelKeys.LISTENER_EXECUTOR,
dependencies.getListenerExecutorInjector());
addScheduledExecutorDependency(
containerBuilder,
model,
ModelKeys.EVICTION_EXECUTOR,
dependencies.getEvictionExecutorInjector());
addScheduledExecutorDependency(
containerBuilder,
model,
ModelKeys.REPLICATION_QUEUE_EXECUTOR,
dependencies.getReplicationQueueExecutorInjector());
newControllers.add(containerBuilder.install());
log.debugf("%s cache container installed", name);
}
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 =
CacheResourceDefinition.JNDI_NAME.resolveModelAttribute(context, cacheModel))
.isDefined())
? resolvedValue.asString()
: null;
final ServiceController.Mode initialMode =
StartMode.valueOf(
CacheResourceDefinition.START.resolveModelAttribute(context, cacheModel).asString())
.getMode();
final ModuleIdentifier moduleId =
(resolvedValue =
CacheResourceDefinition.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 =
CacheContainerResourceDefinition.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,
InfinispanJndiName.createCacheJndiName(jndiName, containerName, cacheName),
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);
}