private ConfigurationBuilder getCB() {
ConfigurationBuilder cb = new ConfigurationBuilder();
cb.clustering()
.cacheMode(CacheMode.DIST_SYNC)
.sync()
.replTimeout(60000)
.stateTransfer()
.timeout(180000)
.fetchInMemoryState(true)
.hash()
.numOwners(1);
// transactions
cb.transaction()
.transactionMode(TransactionMode.TRANSACTIONAL)
.lockingMode(LockingMode.PESSIMISTIC)
.syncCommitPhase(true)
.syncRollbackPhase(true);
// cb.transaction().transactionMode(TransactionMode.NON_TRANSACTIONAL);
cb.loaders().passivation(false).preload(true).shared(true);
// Make it really shared by adding the test's name as store name
cb.loaders()
.addStore(DummyInMemoryCacheStoreConfigurationBuilder.class)
.storeName(getClass().getSimpleName())
.async()
.disable();
return cb;
}
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder config = getDefaultStandaloneCacheConfig(false);
config
.loaders()
.addStore(DummyInMemoryCacheStoreConfigurationBuilder.class)
.storeName(this.getClass().getName())
.slow(true)
.async()
.enable()
.threadPoolSize(1)
.build();
return TestCacheManagerFactory.createCacheManager(config);
}
private void recreateCacheManager() {
ConfigurationBuilder cfg = new ConfigurationBuilder();
cfg.loaders()
.preload(true)
.passivation(true)
.addStore()
.cacheStore(new DummyInMemoryCacheStore())
.purgeOnStartup(true)
.indexing()
.enable()
.addProperty("default.directory_provider", "ram")
.addProperty("lucene_version", "LUCENE_CURRENT");
cm = TestCacheManagerFactory.createCacheManager(cfg);
cache = cm.getCache();
store = TestingUtil.extractComponent(cache, CacheLoaderManager.class).getCacheStore();
search = Search.getSearchManager(cache);
}
@Override
public void readElement(
XMLExtendedStreamReader xmlExtendedStreamReader,
ConfigurationBuilderHolder configurationBuilderHolder)
throws XMLStreamException {
ConfigurationBuilder builder = configurationBuilderHolder.getCurrentConfigurationBuilder();
Element element = Element.forName(xmlExtendedStreamReader.getLocalName());
switch (element) {
case MONGODB_STORE:
{
parseMongoDBStore(
xmlExtendedStreamReader,
builder.loaders(),
configurationBuilderHolder.getClassLoader());
break;
}
default:
{
throw ParseUtils.unexpectedElement(xmlExtendedStreamReader);
}
}
}
@BeforeClass
public void setup() throws Exception {
ConfigurationBuilder serverBuilder = TestCacheManagerFactory.getDefaultCacheConfiguration(true);
serverBuilder
.eviction()
.maxEntries(100)
.strategy(EvictionStrategy.UNORDERED)
.expiration()
.wakeUpInterval(10L);
serverCacheManager = TestCacheManagerFactory.createCacheManager(serverBuilder);
serverCache = serverCacheManager.getCache();
sourceServer = TestHelper.startHotRodServer(serverCacheManager);
remoteSourceCacheManager = new RemoteCacheManager("localhost", sourceServer.getPort());
remoteSourceCacheManager.start();
remoteSourceCache = remoteSourceCacheManager.getCache();
ConfigurationBuilder clientBuilder =
TestCacheManagerFactory.getDefaultCacheConfiguration(false);
clientBuilder
.loaders()
.addStore(RemoteCacheStoreConfigurationBuilder.class)
.hotRodWrapping(true)
.addServer()
.host("localhost")
.port(sourceServer.getPort());
targetCacheManager = TestCacheManagerFactory.createCacheManager(clientBuilder);
targetCache = targetCacheManager.getCache();
targetServer = TestHelper.startHotRodServer(targetCacheManager);
remoteTargetCacheManager = new RemoteCacheManager("localhost", targetServer.getPort());
remoteTargetCacheManager.start();
remoteTargetCache = remoteTargetCacheManager.getCache();
marshaller = remoteTargetCacheManager.getMarshaller();
}
@Override
protected void createCacheManagers() throws Throwable {
ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, true);
builder.loaders().passivation(true).addStore().cacheStore(new DummyInMemoryCacheStore());
createClusteredCaches(2, "atomic", builder);
}
/**
* Create a Configuration object initialized from the operation ModelNode
*
* @param containerName the name of the cache container
* @param cache ModelNode representing cache configuration
* @param builder ConfigurationBuilder object to add data to
* @return initialised Configuration object
*/
void processModelNode(
OperationContext context,
String containerName,
ModelNode cache,
ConfigurationBuilder builder,
List<Dependency<?>> dependencies)
throws OperationFailedException {
final Indexing indexing =
Indexing.valueOf(
CommonAttributes.INDEXING.resolveModelAttribute(context, cache).asString());
final boolean batching =
CommonAttributes.BATCHING.resolveModelAttribute(context, cache).asBoolean();
// set the cache mode (may be modified when setting up clustering attributes)
builder.clustering().cacheMode(this.mode);
final ModelNode indexingPropertiesModel =
CommonAttributes.INDEXING_PROPERTIES.resolveModelAttribute(context, cache);
Properties indexingProperties = new Properties();
if (indexing.isEnabled() && indexingPropertiesModel.isDefined()) {
for (Property p : indexingPropertiesModel.asPropertyList()) {
String value = p.getValue().asString();
indexingProperties.put(p.getName(), value);
}
}
builder
.indexing()
.enabled(indexing.isEnabled())
.indexLocalOnly(indexing.isLocalOnly())
.withProperties(indexingProperties);
// locking is a child resource
if (cache.hasDefined(ModelKeys.LOCKING)
&& cache.get(ModelKeys.LOCKING, ModelKeys.LOCKING_NAME).isDefined()) {
ModelNode locking = cache.get(ModelKeys.LOCKING, ModelKeys.LOCKING_NAME);
final IsolationLevel isolationLevel =
IsolationLevel.valueOf(
CommonAttributes.ISOLATION.resolveModelAttribute(context, locking).asString());
final boolean striping =
CommonAttributes.STRIPING.resolveModelAttribute(context, locking).asBoolean();
final long acquireTimeout =
CommonAttributes.ACQUIRE_TIMEOUT.resolveModelAttribute(context, locking).asLong();
final int concurrencyLevel =
CommonAttributes.CONCURRENCY_LEVEL.resolveModelAttribute(context, locking).asInt();
builder
.locking()
.isolationLevel(isolationLevel)
.useLockStriping(striping)
.lockAcquisitionTimeout(acquireTimeout)
.concurrencyLevel(concurrencyLevel);
}
TransactionMode txMode = TransactionMode.NONE;
LockingMode lockingMode = LockingMode.OPTIMISTIC;
// locking is a child resource
if (cache.hasDefined(ModelKeys.TRANSACTION)
&& cache.get(ModelKeys.TRANSACTION, ModelKeys.TRANSACTION_NAME).isDefined()) {
ModelNode transaction = cache.get(ModelKeys.TRANSACTION, ModelKeys.TRANSACTION_NAME);
final long stopTimeout =
CommonAttributes.STOP_TIMEOUT.resolveModelAttribute(context, transaction).asLong();
txMode =
TransactionMode.valueOf(
CommonAttributes.MODE.resolveModelAttribute(context, transaction).asString());
lockingMode =
LockingMode.valueOf(
CommonAttributes.LOCKING.resolveModelAttribute(context, transaction).asString());
builder.transaction().cacheStopTimeout(stopTimeout);
}
builder
.transaction()
.transactionMode(txMode.getMode())
.lockingMode(lockingMode)
.useSynchronization(!txMode.isXAEnabled())
.recovery()
.enabled(txMode.isRecoveryEnabled());
if (txMode.isRecoveryEnabled()) {
builder.transaction().syncCommitPhase(true).syncRollbackPhase(true);
}
if (batching) {
builder
.transaction()
.transactionMode(org.infinispan.transaction.TransactionMode.TRANSACTIONAL)
.invocationBatching()
.enable();
} else {
builder.transaction().invocationBatching().disable();
}
// eviction is a child resource
if (cache.hasDefined(ModelKeys.EVICTION)
&& cache.get(ModelKeys.EVICTION, ModelKeys.EVICTION_NAME).isDefined()) {
ModelNode eviction = cache.get(ModelKeys.EVICTION, ModelKeys.EVICTION_NAME);
final EvictionStrategy strategy =
EvictionStrategy.valueOf(
CommonAttributes.EVICTION_STRATEGY
.resolveModelAttribute(context, eviction)
.asString());
builder.eviction().strategy(strategy);
if (strategy.isEnabled()) {
final int maxEntries =
CommonAttributes.MAX_ENTRIES.resolveModelAttribute(context, eviction).asInt();
builder.eviction().maxEntries(maxEntries);
}
}
// expiration is a child resource
if (cache.hasDefined(ModelKeys.EXPIRATION)
&& cache.get(ModelKeys.EXPIRATION, ModelKeys.EXPIRATION_NAME).isDefined()) {
ModelNode expiration = cache.get(ModelKeys.EXPIRATION, ModelKeys.EXPIRATION_NAME);
final long maxIdle =
CommonAttributes.MAX_IDLE.resolveModelAttribute(context, expiration).asLong();
final long lifespan =
CommonAttributes.LIFESPAN.resolveModelAttribute(context, expiration).asLong();
final long interval =
CommonAttributes.INTERVAL.resolveModelAttribute(context, expiration).asLong();
builder.expiration().maxIdle(maxIdle).lifespan(lifespan).wakeUpInterval(interval);
// Only enable the reaper thread if we need it
if ((maxIdle > 0) || (lifespan > 0)) {
builder.expiration().enableReaper();
} else {
builder.expiration().disableReaper();
}
}
// stores are a child resource
String storeKey = this.findStoreKey(cache);
if (storeKey != null) {
ModelNode store = this.getStoreModelNode(cache);
final boolean shared =
CommonAttributes.SHARED.resolveModelAttribute(context, store).asBoolean();
final boolean preload =
CommonAttributes.PRELOAD.resolveModelAttribute(context, store).asBoolean();
final boolean passivation =
CommonAttributes.PASSIVATION.resolveModelAttribute(context, store).asBoolean();
final boolean fetchState =
CommonAttributes.FETCH_STATE.resolveModelAttribute(context, store).asBoolean();
final boolean purge =
CommonAttributes.PURGE.resolveModelAttribute(context, store).asBoolean();
final boolean singleton =
CommonAttributes.SINGLETON.resolveModelAttribute(context, store).asBoolean();
final boolean async =
store.hasDefined(ModelKeys.WRITE_BEHIND)
&& store.get(ModelKeys.WRITE_BEHIND, ModelKeys.WRITE_BEHIND_NAME).isDefined();
builder.loaders().shared(shared).preload(preload).passivation(passivation);
LoaderConfigurationBuilder storeBuilder =
builder
.loaders()
.addCacheLoader()
.fetchPersistentState(fetchState)
.purgeOnStartup(purge)
.purgeSynchronously(true);
storeBuilder.singletonStore().enabled(singleton);
if (async) {
ModelNode writeBehind = store.get(ModelKeys.WRITE_BEHIND, ModelKeys.WRITE_BEHIND_NAME);
storeBuilder
.async()
.enable()
.flushLockTimeout(
CommonAttributes.FLUSH_LOCK_TIMEOUT
.resolveModelAttribute(context, writeBehind)
.asLong())
.modificationQueueSize(
CommonAttributes.MODIFICATION_QUEUE_SIZE
.resolveModelAttribute(context, writeBehind)
.asInt())
.shutdownTimeout(
CommonAttributes.SHUTDOWN_TIMEOUT
.resolveModelAttribute(context, writeBehind)
.asLong())
.threadPoolSize(
CommonAttributes.THREAD_POOL_SIZE
.resolveModelAttribute(context, writeBehind)
.asInt());
}
this.buildCacheStore(context, storeBuilder, containerName, store, storeKey, dependencies);
}
}
/**
* Create a Configuration object initialized from the operation ModelNode
*
* @param cache ModelNode representing cache configuration
* @param builder ConfigurationBuilder object to add data to
* @return initialised Configuration object
*/
void processModelNode(
ModelNode cache, ConfigurationBuilder builder, List<Dependency<?>> dependencies) {
String cacheName = cache.require(ModelKeys.NAME).asString();
builder.classLoader(this.getClass().getClassLoader());
builder
.clustering()
.cacheMode(CacheMode.valueOf(cache.require(ModelKeys.CACHE_MODE).asString()));
if (cache.hasDefined(ModelKeys.INDEXING)) {
Indexing indexing = Indexing.valueOf(cache.get(ModelKeys.INDEXING).asString());
builder.indexing().enabled(indexing.isEnabled()).indexLocalOnly(indexing.isLocalOnly());
}
if (cache.hasDefined(ModelKeys.QUEUE_SIZE)) {
int size = cache.get(ModelKeys.QUEUE_SIZE).asInt();
builder.clustering().async().replQueueMaxElements(size).useReplQueue(size > 0);
}
if (cache.hasDefined(ModelKeys.QUEUE_FLUSH_INTERVAL)) {
builder
.clustering()
.async()
.replQueueInterval(cache.get(ModelKeys.QUEUE_FLUSH_INTERVAL).asLong());
}
if (cache.hasDefined(ModelKeys.REMOTE_TIMEOUT)) {
builder.clustering().sync().replTimeout(cache.get(ModelKeys.REMOTE_TIMEOUT).asLong());
}
if (cache.hasDefined(ModelKeys.OWNERS)) {
builder.clustering().hash().numOwners(cache.get(ModelKeys.OWNERS).asInt());
}
if (cache.hasDefined(ModelKeys.VIRTUAL_NODES)) {
builder.clustering().hash().numVirtualNodes(cache.get(ModelKeys.VIRTUAL_NODES).asInt());
}
if (cache.hasDefined(ModelKeys.L1_LIFESPAN)) {
long lifespan = cache.get(ModelKeys.L1_LIFESPAN).asLong();
if (lifespan > 0) {
builder.clustering().l1().enable().lifespan(lifespan);
} else {
builder.clustering().l1().disable();
}
}
// locking is a child resource
if (cache.hasDefined(ModelKeys.LOCKING)
&& cache.get(ModelKeys.LOCKING, ModelKeys.LOCKING_NAME).isDefined()) {
ModelNode locking = cache.get(ModelKeys.LOCKING, ModelKeys.LOCKING_NAME);
if (locking.hasDefined(ModelKeys.ISOLATION)) {
builder
.locking()
.isolationLevel(IsolationLevel.valueOf(locking.get(ModelKeys.ISOLATION).asString()));
}
if (locking.hasDefined(ModelKeys.STRIPING)) {
builder.locking().useLockStriping(locking.get(ModelKeys.STRIPING).asBoolean());
}
if (locking.hasDefined(ModelKeys.ACQUIRE_TIMEOUT)) {
builder.locking().lockAcquisitionTimeout(locking.get(ModelKeys.ACQUIRE_TIMEOUT).asLong());
}
if (locking.hasDefined(ModelKeys.CONCURRENCY_LEVEL)) {
builder.locking().concurrencyLevel(locking.get(ModelKeys.CONCURRENCY_LEVEL).asInt());
}
}
TransactionMode txMode = TransactionMode.NONE;
LockingMode lockingMode = LockingMode.OPTIMISTIC;
// locking is a child resource
if (cache.hasDefined(ModelKeys.TRANSACTION)
&& cache.get(ModelKeys.TRANSACTION, ModelKeys.TRANSACTION_NAME).isDefined()) {
ModelNode transaction = cache.get(ModelKeys.TRANSACTION, ModelKeys.TRANSACTION_NAME);
if (transaction.hasDefined(ModelKeys.STOP_TIMEOUT)) {
builder.transaction().cacheStopTimeout(transaction.get(ModelKeys.STOP_TIMEOUT).asLong());
}
if (transaction.hasDefined(ModelKeys.MODE)) {
txMode = TransactionMode.valueOf(transaction.get(ModelKeys.MODE).asString());
}
if (transaction.hasDefined(ModelKeys.LOCKING)) {
lockingMode = LockingMode.valueOf(transaction.get(ModelKeys.LOCKING).asString());
}
}
builder
.transaction()
.transactionMode(txMode.getMode())
.lockingMode(lockingMode)
.useSynchronization(!txMode.isXAEnabled())
.recovery()
.enabled(txMode.isRecoveryEnabled());
if (txMode.isRecoveryEnabled()) {
builder.transaction().syncCommitPhase(true).syncRollbackPhase(true);
}
if (cache.hasDefined(ModelKeys.BATCHING)) {
InvocationBatchingConfigurationBuilder batchingBuilder =
builder
.transaction()
.transactionMode(org.infinispan.transaction.TransactionMode.TRANSACTIONAL)
.invocationBatching();
if (cache.get(ModelKeys.BATCHING).asBoolean()) {
batchingBuilder.enable();
} else {
batchingBuilder.disable();
}
}
// eviction is a child resource
if (cache.hasDefined(ModelKeys.EVICTION)
&& cache.get(ModelKeys.EVICTION, ModelKeys.EVICTION_NAME).isDefined()) {
ModelNode eviction = cache.get(ModelKeys.EVICTION, ModelKeys.EVICTION_NAME);
if (eviction.hasDefined(ModelKeys.STRATEGY)) {
builder
.eviction()
.strategy(EvictionStrategy.valueOf(eviction.get(ModelKeys.STRATEGY).asString()));
}
if (eviction.hasDefined(ModelKeys.MAX_ENTRIES)) {
builder.eviction().maxEntries(eviction.get(ModelKeys.MAX_ENTRIES).asInt());
}
}
// expiration is a child resource
if (cache.hasDefined(ModelKeys.EXPIRATION)
&& cache.get(ModelKeys.EXPIRATION, ModelKeys.EXPIRATION_NAME).isDefined()) {
ModelNode expiration = cache.get(ModelKeys.EXPIRATION, ModelKeys.EXPIRATION_NAME);
if (expiration.hasDefined(ModelKeys.MAX_IDLE)) {
builder.expiration().maxIdle(expiration.get(ModelKeys.MAX_IDLE).asLong());
}
if (expiration.hasDefined(ModelKeys.LIFESPAN)) {
builder.expiration().lifespan(expiration.get(ModelKeys.LIFESPAN).asLong());
}
if (expiration.hasDefined(ModelKeys.INTERVAL)) {
builder.expiration().wakeUpInterval(expiration.get(ModelKeys.INTERVAL).asLong());
}
}
String storeKey = this.findStoreKey(cache);
if (storeKey != null) {
ModelNode store = this.getStoreModelNode(cache);
builder
.loaders()
.shared(
store.hasDefined(ModelKeys.SHARED) ? store.get(ModelKeys.SHARED).asBoolean() : false)
.preload(
store.hasDefined(ModelKeys.PRELOAD)
? store.get(ModelKeys.PRELOAD).asBoolean()
: false)
.passivation(
store.hasDefined(ModelKeys.PASSIVATION)
? store.get(ModelKeys.PASSIVATION).asBoolean()
: true);
LoaderConfigurationBuilder storeBuilder =
builder
.loaders()
.addCacheLoader()
.fetchPersistentState(
store.hasDefined(ModelKeys.FETCH_STATE)
? store.get(ModelKeys.FETCH_STATE).asBoolean()
: true)
.purgeOnStartup(
store.hasDefined(ModelKeys.PURGE) ? store.get(ModelKeys.PURGE).asBoolean() : true)
.purgeSynchronously(true);
storeBuilder
.singletonStore()
.enabled(
store.hasDefined(ModelKeys.SINGLETON)
? store.get(ModelKeys.SINGLETON).asBoolean()
: false);
this.buildCacheStore(storeBuilder, cacheName, store, storeKey, dependencies);
}
}