ModelNode store = cache.get(ModelKeys.STORE);
CacheLoaderManagerConfig storeManagerConfig = config.getCacheLoaderManagerConfig();
storeManagerConfig.setShared(store.hasDefined(ModelKeys.SHARED) ? store.get(ModelKeys.SHARED).asBoolean() : false);
storeManagerConfig.setPreload(store.hasDefined(ModelKeys.PRELOAD) ? store.get(ModelKeys.PRELOAD).asBoolean() : false);
storeManagerConfig.setPassivation(store.hasDefined(ModelKeys.PASSIVATION) ? store.get(ModelKeys.PASSIVATION).asBoolean() : true);
CacheStoreConfig storeConfig = this.createCacheLoaderConfig(store, locationInjectors);
storeConfig.getSingletonStoreConfig().setSingletonStoreEnabled(store.hasDefined(ModelKeys.SINGLETON) ? store.get(ModelKeys.SINGLETON).asBoolean() : false);
storeConfig.setFetchPersistentState(store.hasDefined(ModelKeys.FETCH_STATE) ? store.get(ModelKeys.FETCH_STATE).asBoolean() : true);
storeConfig.setPurgeOnStartup(store.hasDefined(ModelKeys.PURGE) ? store.get(ModelKeys.PURGE).asBoolean() : true);
if (store.hasDefined(ModelKeys.PROPERTY) && (storeConfig instanceof AbstractCacheStoreConfig)) {
Properties properties = new Properties();
for (Property property: store.get(ModelKeys.PROPERTY).asPropertyList()) {
properties.setProperty(property.getName(), property.getValue().asString());
}
((AbstractCacheStoreConfig) storeConfig).setProperties(properties);
}
storeManagerConfig.addCacheLoaderConfig(storeConfig);
}
configs.put(cacheName, config);
}
if (!configs.containsKey(defaultCache)) {
throw new IllegalArgumentException(String.format("%s is not a valid default cache. The %s cache container does not contain a cache with that name", defaultCache, name));
}
EmbeddedCacheManagerService service = new EmbeddedCacheManagerService(name, defaultCache, global, CacheContainerAdd.this.defaultConfig.clone(), configs);
ServiceBuilder<CacheContainer> builder = service.build(context.getServiceTarget());
if (aliases != null) {
builder.addAliases(aliases);
}
service.addTransportDependency(builder, stack);
if (operation.hasDefined(ModelKeys.LISTENER_EXECUTOR)) {
service.addListenerExecutorDependency(builder, operation.get(ModelKeys.LISTENER_EXECUTOR).asString());
}
if (operation.hasDefined(ModelKeys.EVICTION_EXECUTOR)) {
service.addEvictionExecutorDependency(builder, operation.get(ModelKeys.EVICTION_EXECUTOR).asString());
}
if (operation.hasDefined(ModelKeys.REPLICATION_QUEUE_EXECUTOR)) {
service.addReplicationQueueExecutorDependency(builder, operation.get(ModelKeys.REPLICATION_QUEUE_EXECUTOR).asString());
}
if (transportExecutor != null) {
service.addTransportExecutorDependency(builder, transportExecutor);
}
for (Map.Entry<String, Injector<String>> injector: locationInjectors) {
builder.addDependency(AbstractPathService.pathNameOf(injector.getKey()), String.class, injector.getValue());
}
builder.install();
resultHandler.handleResultComplete();
}
private CacheStoreConfig createCacheLoaderConfig(ModelNode store, List<Map.Entry<String, Injector<String>>> injectors) {
if (store.hasDefined(ModelKeys.CLASS)) {
String className = store.get(ModelKeys.CLASS).asString();
try {
CacheStore cacheStore = Class.forName(className).asSubclass(CacheStore.class).newInstance();
return cacheStore.getConfigurationClass().asSubclass(CacheStoreConfig.class).newInstance();
} catch (Exception e) {
throw new IllegalArgumentException(String.format("%s is not a valid cache store", className), e);
}
}
// If no class, we assume it's a file cache store
String relativeTo = ServerEnvironment.SERVER_DATA_DIR;
if (store.hasDefined(ModelKeys.RELATIVE_TO)) {
relativeTo = store.get(ModelKeys.RELATIVE_TO).asString();
}
FileCacheStoreConfig storeConfig = new FileCacheStoreConfig();
injectors.add(new AbstractMap.SimpleImmutableEntry<String, Injector<String>>(relativeTo, storeConfig.getRelativeToInjector()));
storeConfig.setPath(store.hasDefined(ModelKeys.PATH) ? store.get(ModelKeys.PATH).asString() : name);
return storeConfig;
}
};
runtime.setRuntimeTask(task);
} else {