@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);
}
ServiceController<?> installCacheService(
ServiceTarget target,
String containerName,
String cacheName,
String defaultCache,
ServiceController.Mode initialMode,
Configuration config,
ServiceVerificationHandler verificationHandler) {
final InjectedValue<EmbeddedCacheManager> container = new InjectedValue<EmbeddedCacheManager>();
final CacheDependencies cacheDependencies = new CacheDependencies(container);
final Service<Cache<Object, Object>> service =
new CacheService<Object, Object>(cacheName, cacheDependencies);
final ServiceBuilder<?> builder =
AsynchronousService.addService(
target, CacheService.getServiceName(containerName, cacheName), service)
.addDependency(CacheConfigurationService.getServiceName(containerName, cacheName))
.addDependency(
EmbeddedCacheManagerService.getServiceName(containerName),
EmbeddedCacheManager.class,
container)
.addDependency(
config.clustering().cacheMode().isClustered()
? DependencyType.REQUIRED
: DependencyType.OPTIONAL,
ChannelService.getServiceName(containerName))
.setInitialMode(initialMode);
if (config.transaction().recovery().enabled()) {
builder.addDependency(
TxnServices.JBOSS_TXN_ARJUNA_RECOVERY_MANAGER,
XAResourceRecoveryRegistry.class,
cacheDependencies.getRecoveryRegistryInjector());
}
// add an alias for the default cache
if (cacheName.equals(defaultCache)) {
builder.addAliases(CacheService.getServiceName(containerName, null));
}
if (initialMode == ServiceController.Mode.ACTIVE) {
builder.addListener(verificationHandler);
}
return builder.install();
}
void removeRuntimeServices(
OperationContext context, ModelNode operation, ModelNode containerModel, ModelNode cacheModel)
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 jndiName =
(resolvedValue =
CacheResourceDefinition.JNDI_NAME.resolveModelAttribute(context, cacheModel))
.isDefined()
? resolvedValue.asString()
: null;
String defaultCacheName =
CacheContainerResourceDefinition.DEFAULT_CACHE
.resolveModelAttribute(context, containerModel)
.asString();
boolean defaultCache = cacheName.equals(defaultCacheName);
ContextNames.BindInfo binding =
createCacheBinding(
(jndiName != null)
? JndiNameFactory.parse(jndiName)
: createJndiName(containerName, cacheName));
context.removeService(binding.getBinderServiceName());
// remove the CacheService instance
context.removeService(CacheService.getServiceName(containerName, cacheName));
// remove the cache configuration service
context.removeService(CacheConfigurationService.getServiceName(containerName, cacheName));
for (CacheServiceProvider provider :
ServiceLoader.load(
CacheServiceProvider.class, CacheServiceProvider.class.getClassLoader())) {
for (ServiceName name : provider.getServiceNames(containerName, cacheName, defaultCache)) {
context.removeService(name);
}
}
log.debugf("cache %s removed for container %s", cacheName, containerName);
}
@Test
public void addDependencies() {
this.verifyDependencies(
null,
CacheService.getServiceName(DistributedCacheManagerFactory.DEFAULT_CACHE_CONTAINER, null),
EmbeddedCacheManagerService.getServiceName(null));
this.verifyDependencies(
"web",
CacheService.getServiceName("web", null),
EmbeddedCacheManagerService.getServiceName(null));
this.verifyDependencies(
"web.dist",
CacheService.getServiceName("web", "dist"),
EmbeddedCacheManagerService.getServiceName(null));
this.verifyDependencies(
"alias",
CacheService.getServiceName("alias", null),
EmbeddedCacheManagerService.getServiceName(null));
this.verifyDependencies(
"alias.dist",
CacheService.getServiceName("alias", "dist"),
EmbeddedCacheManagerService.getServiceName(null));
this.verifyDependencies(
"jboss.infinispan.web",
CacheService.getServiceName("web", null),
EmbeddedCacheManagerService.getServiceName(null));
this.verifyDependencies(
"jboss.infinispan.web.dist",
CacheService.getServiceName("web", "dist"),
EmbeddedCacheManagerService.getServiceName(null));
this.verifyDependencies(
"jboss.infinispan.alias",
CacheService.getServiceName("alias", null),
EmbeddedCacheManagerService.getServiceName(null));
this.verifyDependencies(
"jboss.infinispan.alias.dist",
CacheService.getServiceName("alias", "dist"),
EmbeddedCacheManagerService.getServiceName(null));
}
@SuppressWarnings("rawtypes")
ServiceController<?> installJndiService(
ServiceTarget target,
String containerName,
String cacheName,
boolean defaultCache,
String jndiName,
ServiceVerificationHandler verificationHandler) {
final ServiceName cacheServiceName = CacheService.getServiceName(containerName, cacheName);
final ContextNames.BindInfo binding =
createCacheBinding(
(jndiName != null)
? JndiNameFactory.parse(jndiName)
: createJndiName(containerName, cacheName));
final BinderService binder = new BinderService(binding.getBindName());
ServiceBuilder<?> builder =
target
.addService(binding.getBinderServiceName(), binder)
.addAliases(ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(binding.getBindName()))
.addDependency(
cacheServiceName,
Cache.class,
new ManagedReferenceInjector<Cache>(binder.getManagedObjectInjector()))
.addDependency(
binding.getParentContextServiceName(),
ServiceBasedNamingStore.class,
binder.getNamingStoreInjector())
.setInitialMode(ServiceController.Mode.PASSIVE);
if (defaultCache) {
ContextNames.BindInfo defaultBinding =
createCacheBinding(createJndiName(containerName, CacheContainer.DEFAULT_CACHE_ALIAS));
builder.addAliases(
defaultBinding.getBinderServiceName(),
ContextNames.JAVA_CONTEXT_SERVICE_NAME.append(defaultBinding.getBindName()));
}
return builder.install();
}
@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);
}