public InfinispanCacheProperties(Configuration config) { this.transactional = config.transaction().transactionMode().isTransactional(); this.lockOnWrite = this.transactional && (config.transaction().lockingMode() == LockingMode.PESSIMISTIC); this.lockOnRead = this.lockOnWrite && (config.locking().isolationLevel() == IsolationLevel.REPEATABLE_READ); boolean clustered = config.clustering().cacheMode().needsStateTransfer(); boolean hasStore = config.persistence().usingStores(); this.marshalling = clustered || hasStore; this.persistent = clustered || (hasStore && !config.persistence().passivation()); }
private static List<Duration> calculateRetryIntervals(Configuration config) { long timeout = config.locking().lockAcquisitionTimeout(); List<Duration> intervals = new LinkedList<>(); // Generate exponential back-off intervals for (long interval = timeout; interval > 1; interval /= 10) { intervals.add(0, Duration.ofMillis(interval)); } intervals.add(0, Duration.ZERO); return intervals; } }
assertTrue(c.jmxStatistics().enabled()); assertEquals(CacheMode.LOCAL, c.clustering().cacheMode()); assertEquals(30000, c.locking().lockAcquisitionTimeout()); assertEquals(2000, c.locking().concurrencyLevel()); assertEquals(IsolationLevel.NONE, c.locking().isolationLevel()); assertTrue(c.locking().useLockStriping()); assertTrue(c.invocationBatching().enabled()); assertTrue(c.jmxStatistics().enabled()); assertEquals(30500, c.locking().lockAcquisitionTimeout()); assertEquals(2500, c.locking().concurrencyLevel()); assertEquals(IsolationLevel.READ_COMMITTED, c.locking().isolationLevel()); // Converted to READ_COMMITTED by builder assertTrue(c.locking().useLockStriping()); assertTrue(c.invocationBatching().enabled()); assertTrue(c.jmxStatistics().enabled()); assertEquals(31000, c.locking().lockAcquisitionTimeout()); assertEquals(3000, c.locking().concurrencyLevel()); assertEquals(IsolationLevel.REPEATABLE_READ, c.locking().isolationLevel()); // Converted to REPEATABLE_READ by builder assertTrue(c.locking().useLockStriping()); assertTrue(c.clustering().partitionHandling().enabled()); assertTrue(c.jmxStatistics().enabled()); assertEquals(31500, c.locking().lockAcquisitionTimeout()); assertEquals(3500, c.locking().concurrencyLevel()); assertEquals(IsolationLevel.READ_COMMITTED, c.locking().isolationLevel()); assertTrue(c.locking().useLockStriping()); assertEquals(IsolationLevel.REPEATABLE_READ, c.locking().isolationLevel());
assertEquals(1000, defaultCfg.locking().lockAcquisitionTimeout()); assertEquals(100, defaultCfg.locking().concurrencyLevel()); assertEquals(IsolationLevel.REPEATABLE_READ, defaultCfg.locking().isolationLevel()); if (!deprecated) { assertReaperAndTimeoutInfo(defaultCfg); assertEquals(20000, c.locking().lockAcquisitionTimeout()); assertEquals(1000, c.locking().concurrencyLevel()); assertEquals(IsolationLevel.REPEATABLE_READ, c.locking().isolationLevel()); assertEquals(StorageType.OBJECT, c.memory().storageType());
assertEquals(100, c.getCacheConfiguration().locking().concurrencyLevel()); assertEquals(1000, c.getCacheConfiguration().locking().lockAcquisitionTimeout()); assertFalse(c.getCacheConfiguration().transaction().transactionMode().isTransactional()); assertEquals(TransactionMode.NON_TRANSACTIONAL, c.getCacheConfiguration().transaction().transactionMode()); assertEquals(32, c.getCacheConfiguration().locking().concurrencyLevel()); assertEquals(10000, c.getCacheConfiguration().locking().lockAcquisitionTimeout()); assertNotNull(TestingUtil.extractComponent(c, TransactionManager.class)); assertNotNull("This should not be null, since a shared transport should be present", TestingUtil.extractComponent(c, Transport.class)); assertEquals(32, c.getCacheConfiguration().locking().concurrencyLevel()); assertEquals(10000, c.getCacheConfiguration().locking().lockAcquisitionTimeout()); assertEquals(TransactionMode.NON_TRANSACTIONAL, c.getCacheConfiguration().transaction().transactionMode()); assertNotNull("This should not be null, since a shared transport should be present", TestingUtil.extractComponent(c, Transport.class)); assertEquals(32, c.getCacheConfiguration().locking().concurrencyLevel()); assertEquals(10000, c.getCacheConfiguration().locking().lockAcquisitionTimeout()); assertNotNull(TestingUtil.extractComponent(c, TransactionManager.class)); assertNotNull("This should not be null, since a shared transport should be present", TestingUtil.extractComponent(c, Transport.class));
@Override public void call() { Configuration cfg = cm.getDefaultCacheConfiguration(); assertEquals(10000, cfg.locking().concurrencyLevel()); assertEquals(IsolationLevel.REPEATABLE_READ, cfg.locking().isolationLevel()); }
AdvancedCache<Object, Object> cache = cm.getCache().getAdvancedCache(); DataContainer ddc = DefaultDataContainer.unBoundedDataContainer(cache.getCacheConfiguration().locking().concurrencyLevel()); ActivationManager activationManager = mock(ActivationManager.class); doNothing().when(activationManager).onUpdate(Mockito.any(), Mockito.anyBoolean());
@Override public Properties getCacheProperties(String containerName, String cacheName) { EmbeddedCacheManager manager = this.cm; if (manager == null) { return null; } String realCacheName = "{" + containerName + "}_{" + cacheName + "}"; if (!manager.cacheExists(realCacheName)) { return null; } Configuration conf = manager.getCache(realCacheName).getAdvancedCache() .getCacheConfiguration(); Properties p = new Properties(); p.setProperty(IClusterServices.cacheProps.TRANSACTION_PROP.toString(), conf.transaction().toString()); p.setProperty(IClusterServices.cacheProps.CLUSTERING_PROP.toString(), conf.clustering().toString()); p.setProperty(IClusterServices.cacheProps.LOCKING_PROP.toString(), conf .locking().toString()); return p; }
compareAttributeSets(name, configurationBefore.expiration().attributes(), configurationAfter.expiration().attributes()); compareAttributeSets(name, configurationBefore.indexing().attributes(), configurationAfter.indexing().attributes()); compareAttributeSets(name, configurationBefore.locking().attributes(), configurationAfter.locking().attributes()); compareAttributeSets(name, configurationBefore.persistence().attributes(), configurationAfter.persistence().attributes()); compareStores(name, configurationBefore.persistence().stores(), configurationAfter.persistence().stores());
assertEquals(31000, replTemplate.locking().lockAcquisitionTimeout()); assertEquals(32000, replConfiguration.locking().lockAcquisitionTimeout()); assertEquals(3000, replTemplate.locking().concurrencyLevel()); assertEquals(3000, replConfiguration.locking().concurrencyLevel());
@Test public void testCustomDataContainer() { ConfigurationBuilder configuration = new ConfigurationBuilder(); configuration.dataContainer().dataContainer(new QueryableDataContainer()); EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager(configuration); try { AdvancedCache<Object, Object> cache = cm.getCache().getAdvancedCache(); DataContainer ddc = DefaultDataContainer.unBoundedDataContainer(cache.getCacheConfiguration().locking().concurrencyLevel()); ActivationManager activationManager = mock(ActivationManager.class); doNothing().when(activationManager).onUpdate(Mockito.any(), Mockito.anyBoolean()); TestingUtil.inject(ddc, new InternalEntryFactoryImpl(), activationManager, TIME_SERVICE, mock(InternalExpirationManager.class)); QueryableDataContainer.setDelegate(ddc); // Verify that the config is correct Assert.assertEquals(cm.getDefaultCacheConfiguration().dataContainer().dataContainer().getClass(), QueryableDataContainer.class); DataContainer container = cache.getDataContainer(); Assert.assertEquals(container.getClass(), InternalDataContainerAdapter.class); DataContainer delegate = ((InternalDataContainerAdapter) container).delegate(); Assert.assertEquals(delegate.getClass(), QueryableDataContainer.class); QueryableDataContainer dataContainer = QueryableDataContainer.class.cast(delegate); cache.put("name", "Pete"); Assert.assertTrue(checkLoggedOperations(dataContainer.getLoggedOperations(), "put(name, Pete", "compute(name,")); } finally { TestingUtil.killCacheManagers(cm); } }
@Override public void call() { Configuration cfg = cm.getCache().getCacheConfiguration(); assertEquals(IsolationLevel.NONE, cfg.locking().isolationLevel()); } });
private static List<Duration> calculateRetryIntervals(Configuration config) { long timeout = config.locking().lockAcquisitionTimeout(); List<Duration> intervals = new LinkedList<>(); // Generate exponential back-off intervals for (long interval = timeout; interval > 1; interval /= 10) { intervals.add(0, Duration.ofMillis(interval)); } intervals.add(0, Duration.ZERO); return intervals; } }
@Test public void testIfSpringEmbeddedCacheManagerFactoryBeanAllowesOverridingConfigurationBuilder() throws Exception { ConfigurationBuilder overriddenBuilder = new ConfigurationBuilder(); overriddenBuilder.locking().concurrencyLevel(100); objectUnderTest = SpringEmbeddedCacheManagerFactoryBeanBuilder .defaultBuilder().fromFile(NAMED_ASYNC_CACHE_CONFIG_LOCATION, getClass()) .withConfigurationBuilder(overriddenBuilder).build(); final SpringEmbeddedCacheManager springEmbeddedCacheManager = objectUnderTest.getObject(); assertEquals( "Concurrency value of LockingLocking for cache configured in" + CACHE_NAME_FROM_CONFIGURATION_FILE + "is equal to 5000. But later Configuration Builder overrides " + "this setting to 100. Obviously created SpringEmbeddedCacheManagerFactoryBean does not support " + "this kind of overriding.", 100, springEmbeddedCacheManager.getNativeCacheManager().getDefaultCacheConfiguration().locking() .concurrencyLevel()); }
@Override public void call() { Configuration cfg = cm.getCache().getCacheConfiguration(); assertEquals(IsolationLevel.READ_COMMITTED, cfg.locking().isolationLevel()); } });
private static List<Duration> calculateRetryIntervals(Configuration config) { long timeout = config.locking().lockAcquisitionTimeout(); List<Duration> intervals = new LinkedList<>(); // Generate exponential back-off intervals for (long interval = timeout; interval > 1; interval /= 10) { intervals.add(0, Duration.ofMillis(interval)); } intervals.add(0, Duration.ZERO); return intervals; } }
@Test public void testIfSpringEmbeddedCacheManagerFactoryBeanAllowesOverridingConfigurationBuilder() throws Exception { ConfigurationBuilder overriddenBuilder = new ConfigurationBuilder(); overriddenBuilder.locking().concurrencyLevel(100); objectUnderTest = SpringEmbeddedCacheManagerFactoryBeanBuilder .defaultBuilder().fromFile(NAMED_ASYNC_CACHE_CONFIG_LOCATION, getClass()) .withConfigurationBuilder(overriddenBuilder).build(); final SpringEmbeddedCacheManager springEmbeddedCacheManager = objectUnderTest.getObject(); assertEquals( "Concurrency value of LockingLocking for cache configured in" + CACHE_NAME_FROM_CONFIGURATION_FILE + "is equal to 5000. But later Configuration Builder overrides " + "this setting to 100. Obviously created SpringEmbeddedCacheManagerFactoryBean does not support " + "this kind of overriding.", 100, springEmbeddedCacheManager.getNativeCacheManager().getDefaultCacheConfiguration().locking() .concurrencyLevel()); }
/** * Checks if the configuration (and the transaction manager) is able to handle client transactions. */ private void validateConfiguration(AdvancedCache<byte[], byte[]> cache) { Configuration configuration = cache.getCacheConfiguration(); if (!configuration.transaction().transactionMode().isTransactional()) { throw log.expectedTransactionalCache(cache.getName()); } if (configuration.locking().isolationLevel() != IsolationLevel.REPEATABLE_READ) { throw log.unexpectedIsolationLevel(cache.getName()); } //TODO because of ISPN-7672, optimistic and total order transactions needs versions. however, versioning is currently broken if (configuration.transaction().lockingMode() == LockingMode.OPTIMISTIC || configuration.transaction().transactionProtocol() == TransactionProtocol.TOTAL_ORDER) { //no Log. see comment above throw new IllegalStateException( String.format("Cache '%s' cannot use Optimistic neither Total Order transactions.", cache.getName())); } }
public DistributedCacheManager(LocalDistributableSessionManager manager, Cache<String, Map<Object, Object>> cache, Registry<String, Void> registry, SharedLocalYieldingClusterLockManager lockManager, SessionAttributeStorage<T> attributeStorage, BatchingManager batchingManager, CacheInvoker invoker, KeyAffinityServiceFactory affinityFactory) { this.manager = manager; this.lockManager = lockManager; this.cache = cache; this.attributeStorage = attributeStorage; this.batchingManager = batchingManager; this.invoker = new ForceSynchronousCacheInvoker(invoker); this.lockTimeout = this.cache.getCacheConfiguration().locking().lockAcquisitionTimeout(); Configuration configuration = this.cache.getCacheConfiguration(); this.passivationEnabled = configuration.loaders().passivation() && !configuration.loaders().shared() && !configuration.loaders().cacheLoaders().isEmpty(); this.persistenceEnabled = !configuration.loaders().passivation() && !configuration.loaders().cacheLoaders().isEmpty(); this.registry = registry; this.affinity = affinityFactory.createService(cache, this); }
@Test public void testIfSpringEmbeddedCacheManagerFactoryBeanAllowesOverridingConfigurationBuilder() throws Exception { ConfigurationBuilder overriddenBuilder = new ConfigurationBuilder(); overriddenBuilder.locking().concurrencyLevel(100); objectUnderTest = SpringEmbeddedCacheManagerFactoryBeanBuilder .defaultBuilder().fromFile(NAMED_ASYNC_CACHE_CONFIG_LOCATION, getClass()) .withConfigurationBuilder(overriddenBuilder).build(); final SpringEmbeddedCacheManager springEmbeddedCacheManager = objectUnderTest.getObject(); assertEquals( "Concurrency value of LockingLocking for cache configured in" + CACHE_NAME_FROM_CONFIGURATION_FILE + "is equal to 5000. But later Configuration Builder overrides " + "this setting to 100. Obviously created SpringEmbeddedCacheManagerFactoryBean does not support " + "this kind of overriding.", 100, springEmbeddedCacheManager.getNativeCacheManager().getDefaultCacheConfiguration().locking() .concurrencyLevel()); }