private void putValuesInCacheAndCloseCacheManager() { Cache<Long, String> preConfigured = persistentCacheManager.getCache(PERSISTENT_CACHE, Long.class, String.class); preConfigured.put(1L, "foo"); persistentCacheManager.close(); }
@Test public void testDestroyLoop() throws Exception { for (int i = 0; i < 10; i++) { try (CacheManagerContainer cmc = new CacheManagerContainer(10, this::createCacheManager)) { // just put in one and get from another cmc.cacheManagerList.get(0).getCache(CACHE_NAME, Long.class, String.class).put(1L, "value"); assertThat(cmc.cacheManagerList.get(5).getCache(CACHE_NAME, Long.class, String.class).get(1L), is("value")); } destroyCacheManager(); } }
@Test public void testBasicClusteredWriteBehind() { try (PersistentCacheManager cacheManager = createCacheManager()) { Cache<Long, String> cache = cacheManager.getCache(CACHE_NAME, Long.class, String.class); for (int i = 0; i < 10; i++) { put(cache, String.valueOf(i)); } assertValue(cache, String.valueOf(9)); verifyRecords(cache); cache.clear(); } }
@Test public void testDestroyCacheWhenSingleClientIsConnected() throws CachePersistenceException { PersistentCacheManager persistentCacheManager = clusteredCacheManagerBuilder.build(true); persistentCacheManager.destroyCache(CLUSTERED_CACHE); final Cache<Long, String> cache = persistentCacheManager.getCache(CLUSTERED_CACHE, Long.class, String.class); assertThat(cache, nullValue()); persistentCacheManager.close(); }
@Test public void testDestroyNonExistentCache() throws CachePersistenceException { PersistentCacheManager persistentCacheManager = clusteredCacheManagerBuilder.build(true); String nonExistent = "this-is-not-the-cache-you-are-looking-for"; assertThat(persistentCacheManager.getCache(nonExistent, Long.class, String.class), nullValue()); persistentCacheManager.destroyCache(nonExistent); persistentCacheManager.close(); }
@Test public void reconnectDuringCacheDestroy() throws Exception { Cache<Long, String> cache = cacheManager.createCache("clustered-cache", config); assertThat(cache, notNullValue()); expireLease(); cacheManager.destroyCache("clustered-cache"); assertThat(cacheManager.getCache("clustered-cache", Long.class, String.class), nullValue()); }
@Test public void testPutIfAbsentExpirationPropagatedToHigherTiers() throws CachePersistenceException { CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder = cacheManagerBuilder(oneSecondExpiration()); try(PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true)) { Cache<Long, String> cache = cacheManager.getCache(CLUSTERED_CACHE, Long.class, String.class); cache.put(1L, "value"); // store on the cluster cache.putIfAbsent(1L, "newvalue"); // push it up on heap tier timeSource.advanceTime(1500); // go after expiration assertThat(cache.get(1L)).isEqualTo(null); // the value should have expired } } }
@Before public void setUp() throws Exception { super.setUp(); CLUSTER.getClusterControl().startAllServers(); CLUSTER.getClusterControl().waitForActive(); cacheManager1 = createCacheManager(CLUSTER.getConnectionURI()); cacheManager2 = createCacheManager(CLUSTER.getConnectionURI()); client1 = cacheManager1.getCache(CACHE_NAME, Long.class, String.class); client2 = cacheManager2.getCache(CACHE_NAME, Long.class, String.class); }
@Test public void testDestroyCacheWithUnknownAlias() throws Exception { File file = new File(getStoragePath(), "testDestroyUnknownAlias"); initCacheManager(file); Cache<Long, String > cache = persistentCacheManager.getCache(PERSISTENT_CACHE, Long.class, String.class); cache.put(1L, "One"); persistentCacheManager.close(); PersistentCacheManager anotherPersistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder() .with(new CacheManagerPersistenceConfiguration(file)).build(true); anotherPersistentCacheManager.destroyCache(PERSISTENT_CACHE); assertThat(file, not(containsCacheDirectory(PERSISTENT_CACHE))); }
@Before public void setUp() throws Exception { super.setUp(); CLUSTER.getClusterControl().startAllServers(); CLUSTER.getClusterControl().waitForActive(); CLUSTER.getClusterControl().waitForRunningPassivesInStandby(); cacheManager1 = createCacheManager(CLUSTER.getConnectionURI()); cacheManager2 = createCacheManager(CLUSTER.getConnectionURI()); client1 = cacheManager1.getCache(CACHE_NAME, Long.class, String.class); client2 = cacheManager2.getCache(CACHE_NAME, Long.class, String.class); }
@Test public void testGetExpiredSingleClient() { TestTimeSource timeSource = new TestTimeSource(); TimeSourceConfiguration timeSourceConfiguration = new TimeSourceConfiguration(timeSource); final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder = commonClusteredCacheManagerBuilder.using(timeSourceConfiguration); final PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true); final Cache<Long, String> cache = cacheManager.getCache("clustered-cache", Long.class, String.class); cache.put(1L, "value"); assertThat(cache.get(1L), is("value")); timeSource.advanceTime(1); assertThat(cache.get(1L), nullValue()); cacheManager.close(); }
@Test public void testClusteredCacheWithSerializableValue() throws Exception { final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder = newCacheManagerBuilder().with(cluster(CLUSTER_URI).autoCreate()) .withCache("clustered-cache", newCacheConfigurationBuilder(Long.class, Person.class, newResourcePoolsBuilder().with(clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB)))); PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true); Cache<Long, Person> cache = cacheManager.getCache("clustered-cache", Long.class, Person.class); cache.put(38L, new Person("Clustered Joe", 28)); cacheManager.close(); cacheManager = clusteredCacheManagerBuilder.build(true); cache = cacheManager.getCache("clustered-cache", Long.class, Person.class); assertThat(cache.get(38L).name, is("Clustered Joe")); }
@Before public void setUp() throws Exception { super.setUp(); CLUSTER.getClusterControl().startAllServers(); CLUSTER.getClusterControl().waitForActive(); cacheManager = createCacheManager(CLUSTER.getConnectionURI()); cache = cacheManager.getCache(CACHE_NAME, Long.class, String.class); }
@Test public void testStatefulSerializerWithDiskStateRepository() throws Exception { CacheManagerBuilder<PersistentCacheManager> cmBuilder = newCacheManagerBuilder().with(persistence(temporaryFolder.newFolder() .getAbsolutePath())) .withCache("myCache", newCacheConfigurationBuilder(Long.class, Person.class, heap(10).disk(50, MemoryUnit.MB, true)) .withValueSerializer(CompactJavaSerializer.asTypedSerializer())); PersistentCacheManager cacheManager = cmBuilder.build(true); Cache<Long, Person> myCache = cacheManager.getCache("myCache", Long.class, Person.class); myCache.put(42L, new Person("John", 42)); myCache.put(35L, new Person("Marie", 35)); cacheManager.close(); cacheManager.init(); myCache = cacheManager.getCache("myCache", Long.class, Person.class); assertThat(myCache.get(42L).getName(), is("John")); }
@Test public void testCreateCacheWithSameAliasAfterDestroy() throws Exception { File file = new File(getStoragePath(), "testDestroy"); initCacheManager(file); persistentCacheManager.destroyCache(PERSISTENT_CACHE); persistentCacheManager.createCache(PERSISTENT_CACHE, CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, newResourcePoolsBuilder() .heap(10, EntryUnit.ENTRIES) .disk(10L, MemoryUnit.MB, true)) .build()); assertNotNull(persistentCacheManager.getCache(PERSISTENT_CACHE, Long.class, String.class)); persistentCacheManager.close(); }
public static void testProgrammaticClusteredCache(OsgiTestUtils.Cluster cluster) throws Throwable { try (PersistentCacheManager cacheManager = newCacheManagerBuilder() .with(cluster(cluster.getConnectionUri()).autoCreate()) .withCache("clustered-cache", newCacheConfigurationBuilder(Long.class, String.class, newResourcePoolsBuilder().with(clusteredDedicated("main", 2, MemoryUnit.MB)))) .build(true)) { final Cache<Long, String> cache = cacheManager.getCache("clustered-cache", Long.class, String.class); cache.put(1L, "value"); assertThat(cache.get(1L), is("value")); } }
@Before public void setUp() throws Exception { super.setUp(); CLUSTER.getClusterControl().startAllServers(); CLUSTER.getClusterControl().waitForActive(); CLUSTER.getClusterControl().waitForRunningPassivesInStandby(); cacheManager = createCacheManager(CLUSTER.getConnectionURI()); cache = cacheManager.getCache(CACHE_NAME, Long.class, String.class); }
@Test public void testCloseCacheManagerSingleClient() { CacheManagerBuilder<PersistentCacheManager> cacheManagerBuilder = clusteredCacheManagerBuilder .withCache("test", newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.newResourcePoolsBuilder() .with(ClusteredResourcePoolBuilder.clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB)))); PersistentCacheManager persistentCacheManager1 = cacheManagerBuilder.build(true); persistentCacheManager1.close(); persistentCacheManager1.init(); Cache<Long, String> cache = persistentCacheManager1.getCache("test", Long.class, String.class); cache.put(1L, "One"); assertThat(cache.get(1L), is("One")); persistentCacheManager1.close(); }
@Test public void testTieredClusteredCache() throws Exception { final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder = newCacheManagerBuilder() .with(cluster(CLUSTER_URI).autoCreate()) .withCache("clustered-cache", newCacheConfigurationBuilder(Long.class, String.class, heap(2) .with(clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB)))); final PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true); final Cache<Long, String> cache = cacheManager.getCache("clustered-cache", Long.class, String.class); cache.put(1L, "value"); assertThat(cache.get(1L), is("value")); cacheManager.close(); }
@Test public void testClusteredCacheSingleClient() throws Exception { final CacheManagerBuilder<PersistentCacheManager> clusteredCacheManagerBuilder = newCacheManagerBuilder() .with(cluster(CLUSTER_URI).autoCreate()) .withCache("clustered-cache", newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.newResourcePoolsBuilder() .with(clusteredDedicated("primary-server-resource", 2, MemoryUnit.MB)))); final PersistentCacheManager cacheManager = clusteredCacheManagerBuilder.build(true); final Cache<Long, String> cache = cacheManager.getCache("clustered-cache", Long.class, String.class); cache.put(1L, "value"); assertThat(cache.get(1L), is("value")); cacheManager.close(); }