@Override public XSiteAdminOperations getOperations() { return cache.getAdvancedCache().getComponentRegistry().getComponent(XSiteAdminOperations.class); } };
public static SearchIntegrator extractSearchFactory(Cache cache) { ComponentRegistry componentRegistry = cache.getAdvancedCache().getComponentRegistry(); SearchIntegrator component = componentRegistry.getComponent(SearchIntegrator.class); assertNotNull(component); return component; }
public void testAllocatedAmountEqualWithExpiration() { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.memory() .size(MemoryUnit.MEGABYTES.toBytes(20)) .evictionType(EvictionType.MEMORY) .storageType(StorageType.OFF_HEAP); EmbeddedCacheManager manager = TestCacheManagerFactory.createCacheManager(builder); AdvancedCache<Object, Object> cache = manager.getCache().getAdvancedCache(); cache.put("lifespan", "value", 1, TimeUnit.MINUTES); cache.put("both", "value", 1, TimeUnit.MINUTES, 1, TimeUnit.MINUTES); cache.put("maxidle", "value", -1, TimeUnit.MINUTES, 1, TimeUnit.MINUTES); OffHeapMemoryAllocator allocator = cache.getComponentRegistry().getComponent( OffHeapMemoryAllocator.class); BoundedOffHeapDataContainer container = (BoundedOffHeapDataContainer) getContainer(cache); assertEquals(allocator.getAllocatedAmount(), container.currentSize); cache.clear(); assertEquals(allocator.getAllocatedAmount(), container.currentSize); }
try { final String cacheName = "to-be-removed"; local.defineConfiguration(cacheName, local.getDefaultCacheConfiguration()); Cache<String, Object> cache = local.getCache(cacheName); assertTrue(local.isRunning(cacheName)); cache.put("1", wrap("1", "v1")); assertCacheEntry(cache, "1", "v1", -1, -1); ByRef<Boolean> passivate = new ByRef<>(false); PersistenceManager actual = cache.getAdvancedCache().getComponentRegistry().getComponent(PersistenceManager.class); PersistenceManager stub = new PersistenceManagerStub() { @Override TestingUtil.replaceComponent(cache, PersistenceManager.class, stub, true); local.administration().removeCache(cacheName); assertFalse(local.isRunning(cacheName)); assertFalse(passivate.get()); assertEquals(0, actual.size()); } finally {
public void testCacheStopped() { final String site = "LON"; String key = key(site); String val = val(site); cache(site, 0).put(key, val); Cache<Object,Object> backup = backup(site); final GlobalComponentRegistry gcr = backup.getAdvancedCache().getComponentRegistry().getGlobalComponentRegistry(); assertEquals(backup.get(key), val); assertTrue(backup.getStatus().allowInvocations()); backup.stop(); eventually(new Condition() { @Override public boolean isSatisfied() throws Exception { BackupReceiverRepositoryImpl component = (BackupReceiverRepositoryImpl) gcr.getComponent(BackupReceiverRepository.class); return component.get(site, EmbeddedCacheManager.DEFAULT_CACHE_NAME) == null; } }); assertFalse(backup.getStatus().allowInvocations()); backup.start(); log.trace("About to put the 2nd value"); cache(site, 0).put(key, "v2"); assertEquals(backup(site).get(key), "v2"); assertTrue(backup.getStatus().allowInvocations()); }
Configuration configuration; if (baseCacheName != null) { configuration = cacheManager.getCacheConfiguration(baseCacheName); if (configuration == null) { throw log.nonExistentCache(baseCacheName); configuration = cacheManager.getDefaultCacheConfiguration(); baseCacheName = BasicCacheContainer.DEFAULT_CACHE_NAME; if (cacheManager.cacheExists(cacheName)) { throw log.cacheAlreadyExists(cacheName); if (configuration.clustering().cacheMode().isClustered()) { AdvancedCache<?, ?> clusteredCache = cacheManager.getCache(baseCacheName).getAdvancedCache(); RpcManager rpc = clusteredCache.getRpcManager(); CommandsFactory factory = clusteredCache.getComponentRegistry().getComponent(CommandsFactory.class);
public void testPutWithFailures() { populateKeys(cache("LON", 0)); BackupSenderImpl bs = (BackupSenderImpl) cache("LON", 0).getAdvancedCache().getComponentRegistry().getComponent(BackupSender.class); OfflineStatus nycStatus = bs.getOfflineStatus("NYC"); assertEquals(BackupSender.BringSiteOnlineResponse.ALREADY_ONLINE, bs.bringSiteOnline("NYC")); cache("LON", 0).put(keys[i], "v" + i); fail("This should have failed"); } catch (Exception e) { assertEquals(i + 1, nycStatus.getFailureCount()); cache("LON", 0).put(keys[i], "v" + i);
public void testNodeJoin() throws Exception { List<MagicKey> keys = init(); EmbeddedCacheManager cm4 = addClusterEnabledCacheManager(defaultConfig, TRANSPORT_FLAGS); int startTopologyId = c1.getAdvancedCache().getDistributionManager().getCacheTopology().getTopologyId(); CountDownLatch stateAppliedLatch = new CountDownLatch(1); TestingUtil.addCacheStartingHook(cm4, (name, cr) -> { PerCacheInboundInvocationHandler originalHandler = cr.getComponent(PerCacheInboundInvocationHandler.class); AbstractDelegatingHandler newHandler = new AbstractDelegatingHandler(originalHandler) { @Override BasicComponentRegistry bcr = cr.getComponent(BasicComponentRegistry.class); bcr.replaceComponent(PerCacheInboundInvocationHandler.class.getName(), newHandler, false); cr.rewire(); cr.cacheComponents(); }); Future<Cache> c4Future = fork(() -> cm4.getCache(CACHE_NAME)); assertTrue(statePushedLatch.await(10, TimeUnit.SECONDS)); assertFalse(stateAppliedLatch.await(100, TimeUnit.MILLISECONDS)); assertEquals(0, stateAppliedLatch.getCount()); bltm.confirmTopologyUpdate(CacheTopology.Phase.NO_REBALANCE); int copies = Stream.of(c1, c2, c3, c4).mapToInt(c -> c.getAdvancedCache().getDataContainer().containsKey(key) ? 1 : 0).sum(); assertEquals("Key " + key + " has incorrect number of copies", 2, copies);
public void testRollbackNoCommit() throws Throwable { String key = key("LON"); String val = val("LON"); ComponentRegistry cr = backup("LON").getAdvancedCache().getComponentRegistry(); GlobalComponentRegistry gcr = cr.getGlobalComponentRegistry(); BackupReceiverRepositoryImpl brr = (BackupReceiverRepositoryImpl) gcr.getComponent(BackupReceiverRepository.class); BackupReceiver backupCacheManager = brr.getBackupReceiver("LON", CacheContainer.DEFAULT_CACHE_NAME); BackupReceiverWrapper brWrapper = new BackupReceiverWrapper(backupCacheManager); brr.replace("LON", CacheContainer.DEFAULT_CACHE_NAME, brWrapper); assertNull(brWrapper.received); cache("LON", 0).put(key, val); assertNotNull(brWrapper.received); assertEquals(backup("LON").get(key), val); brWrapper.received = null; TransactionManager tmLon0 = cache("LON", 0).getAdvancedCache().getTransactionManager(); assertNull(brWrapper.received); tmLon0.begin(); cache("LON", 0).put(key, val); log.trace("Before rollback!"); tmLon0.rollback(); assertNull(brWrapper.received); }
public void testPutWithFailures() { populateKeys(cache("LON", 0)); EmbeddedCacheManager manager = cache("LON", 0).getCacheManager(); Transport transport = manager.getGlobalComponentRegistry().getComponent(Transport.class); DelegatingTransport delegatingTransport = new DelegatingTransport(transport); TestingUtil.replaceComponent(manager, Transport.class, delegatingTransport, true); ComponentRegistry registry = cache("LON", 0).getAdvancedCache().getComponentRegistry(); BackupSenderImpl bs = (BackupSenderImpl) registry.getComponent(BackupSender.class); OfflineStatus offlineStatus = bs.getOfflineStatus("NYC"); for (int i = 0; i < FAILURES; i++) { try { cache("LON", 0).put(KEYS[i], "v" + i); fail("This should have failed"); } catch (Exception e) { assertEquals("v" + i, cache("LON", 0).get(KEYS[i])); assertEquals(BackupSender.BringSiteOnlineResponse.BROUGHT_ONLINE, bs.bringSiteOnline("NYC"));
public void testKeySegmentFilter() { Cache<Integer, String> cache = getCache(0); int range = 12; // First populate the cache with a bunch of values IntStream.range(0, range).boxed().forEach(i -> cache.put(i, i + "-value")); assertEquals(range, cache.size()); CacheSet<Map.Entry<Integer, String>> entrySet = cache.entrySet(); // Take the first half of the segments int segments = cache.getCacheConfiguration().clustering().hash().numSegments() / 2; AtomicInteger realCount = new AtomicInteger(); KeyPartitioner keyPartitioner = cache.getAdvancedCache().getComponentRegistry().getComponent(KeyPartitioner.class); cache.forEach((k, v) -> { if (segments >= keyPartitioner.getSegment(k)) { realCount.incrementAndGet(); } }); assertEquals(realCount.get(), createStream(entrySet).filterKeySegments( IntStream.range(0, segments).boxed().collect(Collectors.toSet())).count()); }
/** * Verifies if the indexing interceptor is aware of a specific list of types. * * @param cache the cache containing the indexes * @param types vararg listing the types the indexing engine should know */ private void assertIndexingKnows(Cache<Object, Object> cache, Class<?>... types) { ComponentRegistry cr = cache.getAdvancedCache().getComponentRegistry(); SearchIntegrator searchIntegrator = cr.getComponent(SearchIntegrator.class); assertNotNull(searchIntegrator); IndexedTypeMap<EntityIndexBinding> indexBindingForEntity = searchIntegrator.unwrap(ExtendedSearchIntegrator.class).getIndexBindings(); assertNotNull(indexBindingForEntity); IndexedTypeSet keySet = indexBindingForEntity.keySet(); assertEquals(types.length, keySet.size()); assertTrue(keySet.containsAll(IndexedTypeSets.fromClasses(types))); }
@Override public void call() { Cache<String, Map<String, String>> cache = cm.getCache(); EncoderRegistry encoderRegistry = cache.getAdvancedCache().getComponentRegistry().getComponent(EncoderRegistry.class); encoderRegistry.registerTranscoder(new ObjectXMLTranscoder()); // Store a map in the cache Map<String, String> valueMap = new HashMap<>(); valueMap.put("BTC", "Bitcoin"); valueMap.put("ETH", "Ethereum"); valueMap.put("LTC", "Litecoin"); cache.put("CoinMap", valueMap); assertEquals(valueMap, cache.get("CoinMap")); // Obtain the value with a different MediaType AdvancedCache<String, String> xmlCache = (AdvancedCache<String, String>) cache.getAdvancedCache() .withMediaType(APPLICATION_OBJECT_TYPE, APPLICATION_XML_TYPE); assertEquals(xmlCache.get("CoinMap"), "<root><BTC>Bitcoin</BTC><ETH>Ethereum</ETH><LTC>Litecoin</LTC></root>"); // Reading with same configured MediaType should not change content assertEquals(xmlCache.withMediaType(APPLICATION_OBJECT_TYPE, APPLICATION_OBJECT_TYPE).get("CoinMap"), valueMap); // Writing using XML xmlCache.put("AltCoinMap", "<root><CAT>Catcoin</CAT><DOGE>Dogecoin</DOGE></root>"); // Read using object from undecorated cache Map<String, String> map = cache.get("AltCoinMap"); assertEquals(map.get("CAT"), "Catcoin"); assertEquals(map.get("DOGE"), "Dogecoin"); } });
cache.put(i, "value" + i); Future<Object> putFuture = fork(() -> TestingUtil.withTx(cache.getAdvancedCache().getTransactionManager(), () -> { Object prev = cache.put(key, "value" + key + "-new"); LockedStream<Object, Object> stream = cache.getAdvancedCache().lockedStream(); Future<?> forEachFuture = fork(() -> stream.filter(e -> e.getKey().equals(key)).forEach((c, e) -> assertEquals("value" + key + "-new", c.put(e.getKey(), String.valueOf(e.getValue() + "-other"))))); assertEquals("value" + key, putFuture.get(10, TimeUnit.SECONDS)); assertEquals("value" + key + "-new-other", cache.get(key)); LockManager lockManager = cache.getAdvancedCache().getComponentRegistry().getComponent(LockManager.class); assertEquals(0, lockManager.getNumberOfLocksHeld());
@Test public void testStateTransferWithRequestorsForNonExistentL1Value() throws Exception { L1Manager l1Manager = c1.getAdvancedCache().getComponentRegistry().getComponent(L1Manager.class); l1Manager.addRequestor(key, c3.getCacheManager().getAddress()); assertNull(c3.get(key)); assertIsNotInL1(c2, key); assertIsInContainerImmortal(c3, key); assertIsNotInL1(cm.getCache(cacheName), key); assertFalse(DistributionTestHelper.isOwner(c2, key)); assertTrue(DistributionTestHelper.isOwner(c3, key)); assertFalse(DistributionTestHelper.isOwner(cm.getCache(cacheName), key));
@Override public void call() { Cache<String, String> cache = cm.getCache(); EncoderRegistry encoderRegistry = cache.getAdvancedCache().getComponentRegistry().getComponent(EncoderRegistry.class); encoderRegistry.registerTranscoder(new FooBarTranscoder()); cache.put("foo-key", "bar-value"); assertEquals(cache.get("foo-key"), "bar-value"); Cache<String, String> fooCache = (Cache<String, String>) cache.getAdvancedCache().withMediaType("application/foo", "application/foo"); assertEquals(fooCache.get("foo-key"), "foo-value"); Cache<String, String> barCache = (Cache<String, String>) cache.getAdvancedCache().withMediaType("application/bar", "application/bar"); assertEquals(barCache.get("bar-key"), "bar-value"); Cache<String, String> barFooCache = (Cache<String, String>) cache.getAdvancedCache().withMediaType("application/bar", "application/foo"); assertEquals(barFooCache.get("bar-key"), "foo-value"); } });
Cache<String, String> cache0 = cache(0, CACHE_NAME); PassivationManager passivationManager = cache0.getAdvancedCache().getComponentRegistry().getComponent( PassivationManager.class); cache0.addListener(listener, new EventKeyFilter(Event.Type.CACHE_ENTRY_ACTIVATED, key), null); assertEquals(value, cache0.get("not" + key)); assertEquals(0, listener.events.size()); assertEquals(value, cache0.get(key)); assertEquals(2, listener.events.size());
public static StreamSummaryContainer getOrCreateStreamLibContainer(Cache cache) { ComponentRegistry componentRegistry = cache.getAdvancedCache().getComponentRegistry(); StreamSummaryContainer streamLibContainer = componentRegistry.getComponent(StreamSummaryContainer.class); if (streamLibContainer == null) { String cacheName = cache.getName(); String address = String.valueOf(cache.getCacheManager().getAddress()); componentRegistry.registerComponent(new StreamSummaryContainer(cacheName, address), StreamSummaryContainer.class); } return componentRegistry.getComponent(StreamSummaryContainer.class); }
@Test public void testPassivationBlocked() { String key = "key"; String value = "value"; Cache<String, String> cache0 = cache(0, CACHE_NAME); AllCacheEntryListener listener = new AllCacheEntryListener(); cache0.addListener(listener, new EventKeyFilter(Event.Type.CACHE_ENTRY_PASSIVATED, key), null); PassivationManager passivationManager = cache0.getAdvancedCache().getComponentRegistry().getComponent( PassivationManager.class); passivationManager.passivate(new ImmortalCacheEntry(key, value)); assertEquals(2, listener.events.size()); assertEquals(Event.Type.CACHE_ENTRY_PASSIVATED, listener.events.get(0).getType()); assertEquals(key, listener.events.get(0).getKey()); assertEquals(value, listener.events.get(0).getValue()); assertEquals(Event.Type.CACHE_ENTRY_PASSIVATED, listener.events.get(0).getType()); assertEquals(key, listener.events.get(1).getKey()); assertNull(listener.events.get(1).getValue()); passivationManager.passivate(new ImmortalCacheEntry("not" + key, value)); // We shouldn't have received any additional events assertEquals(2, listener.events.size()); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder cb = getDefaultStandaloneCacheConfig(false); configurePersistence(cb); EmbeddedCacheManager manager = TestCacheManagerFactory.createCacheManager(cb); cache = manager.getCache(); ComponentRegistry componentRegistry = cache.getAdvancedCache().getComponentRegistry(); PersistenceManagerImpl pm = (PersistenceManagerImpl) componentRegistry.getComponent(PersistenceManager.class); sm = pm.getMarshaller(); store = TestingUtil.getFirstLoader(cache); keys = new Set[cache.getCacheConfiguration().clustering().hash().numSegments()]; return manager; }