/** * Extracts the value of a field in a given target instance using reflection, able to extract private fields as * well. * * @param target object to extract field from * @param fieldName name of field to extract * * @return field value */ public static <T> T extractField(Object target, String fieldName) { //noinspection unchecked return (T) extractField(target.getClass(), target, fieldName); }
public static CommandsFactory extractCommandsFactory(Cache<?, ?> cache) { if (cache instanceof AbstractDelegatingCache) { // Need to unwrap to the base cache return extractCommandsFactory(extractField(cache, "cache")); } return (CommandsFactory) extractField(cache, "commandsFactory"); }
public static GlobalMarshaller extractGlobalMarshaller(EmbeddedCacheManager cm) { GlobalComponentRegistry gcr = extractField(cm, "globalComponentRegistry"); return (GlobalMarshaller) gcr.getComponent(StreamingMarshaller.class); }
public static void installNewView(Stream<Address> members, EmbeddedCacheManager... where) { installNewView(members, ecm -> { Transport transport = ecm.getTransport(); while (Proxy.isProxyClass(transport.getClass())) { // Unwrap proxies created by the StateSequencer transport = extractField(extractField(transport, "h"), "wrappedInstance"); } return ((JGroupsTransport) transport).getChannel(); }, where); }
public void testSiteMasterPicked() throws NoSuchFieldException, IllegalAccessException { for (TestSite testSite : sites) { for (EmbeddedCacheManager cacheManager : testSite.cacheManagers) { RELAY2 relay2 = getRELAY2(cacheManager); Object site_master_picker = TestingUtil.extractField(RELAY2.class, relay2, "site_master_picker"); assertEquals(SiteMasterPickerImpl.class, site_master_picker.getClass()); } } }
private void verifyLockFactoryForIndexIs(String indexName, Class<? extends LockFactory> expectedType) { Directory directory = directoryByName(indexName); LockFactory lockFactory = TestingUtil.extractField(directory, "lockFactory"); Assert.assertEquals(expectedType, lockFactory.getClass()); }
/** * Add a hook to cache startup sequence that will allow to replace existing component with a mock. * @param cacheContainer * @param consumer */ public static void addCacheStartingHook(CacheContainer cacheContainer, BiConsumer<String, ComponentRegistry> consumer) { GlobalComponentRegistry gcr = extractGlobalComponentRegistry(cacheContainer); extractField(gcr, "moduleLifecycles"); TestingUtil.<Collection<ModuleLifecycle>>replaceField(gcr, "moduleLifecycles", moduleLifecycles -> { Collection<ModuleLifecycle> copy = new ArrayList<>(moduleLifecycles); copy.add(new ModuleLifecycle() { @Override public void cacheStarting(ComponentRegistry cr, Configuration configuration, String cacheName) { consumer.accept(cacheName, cr); } }); return copy; }); }
@Override protected void parseSiteConfiguration(Map<String, RelayConfig.SiteConfig> map) throws Exception { super.parseSiteConfiguration(map); String testName = TestResourceTracker.getCurrentTestName(); map.forEach((s, siteConfig) -> { List<RelayConfig.BridgeConfig> bridges = siteConfig.getBridges(); for (int i = 0; i < bridges.size(); i++) { RelayConfig.BridgeConfig bridgeConfig = bridges.get(i); String config = (String) TestingUtil.extractField(RelayConfig.PropertiesBridgeConfig.class, bridgeConfig, "config"); // Keep the same ports for all the tests, just change the cluster name String clusterName = "bridge-" + (testName != null ? testName : "namenotset"); bridges.set(i, new RelayConfig.PropertiesBridgeConfig(clusterName, config)); } }); } }
@Test public void testIndexingWithCustomLock() throws CyclicDependencyException { EmbeddedCacheManager cacheManager = createClusteredCacheManager(); DependencyGraph<String> graph = TestingUtil.extractField(cacheManager, "cacheDependencyGraph"); cacheManager.defineConfiguration("cache", getIndexedConfigWithCustomLock().build()); startAndIndexData("cache", cacheManager); cacheManager.stop(); List<String> cacheOrder = graph.topologicalSort(); assertTrue(cacheOrder.indexOf("cache") < cacheOrder.indexOf("LuceneIndexesData")); assertTrue(cacheOrder.indexOf("cache") < cacheOrder.indexOf("LuceneIndexesMetadata")); assertTrue(cacheOrder.indexOf("cache") < cacheOrder.indexOf("LuceneIndexesLocking")); assertEquals(cacheManager.getStatus(), ComponentStatus.TERMINATED); }
public static void waitForTopologyPhase(List<Address> expectedMembers, CacheTopology.Phase phase, Cache... caches) { final int TOPOLOGY_TIMEOUT_SECONDS = 60; //Needs to be rather large to prevent sporadic failures on CI final long giveup = System.nanoTime() + TimeUnit.SECONDS.toNanos(TOPOLOGY_TIMEOUT_SECONDS); for (Cache c : caches) { if (c instanceof SecureCacheImpl) { c = (Cache) extractField(SecureCacheImpl.class, c, "delegate"); } DistributionManager distributionManager = c.getAdvancedCache().getDistributionManager(); while (true) { CacheTopology cacheTopology = distributionManager.getCacheTopology(); boolean allMembersExist = cacheTopology != null && cacheTopology.getMembers().containsAll(expectedMembers); boolean isCorrectPhase = cacheTopology != null && cacheTopology.getPhase() == phase; if (allMembersExist && isCorrectPhase) break; if (System.nanoTime() - giveup > 0) { String message = String.format("Timed out waiting for a CacheTopology to be installed with members %s and phase %s. Current topology=%s", expectedMembers, phase, cacheTopology); log.error(message); throw new RuntimeException(message); } LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100)); } } }
private void assertNoLocks() { LockManager lm = TestingUtil.extractLockManager(cache); LockAssert.assertNoLocks(lm); LockContainer lc = TestingUtil.extractField(lm, "lockContainer"); assert lc.size() == 0; } }
private void assertEfficientIndexingUsed(SearchIntegrator searchIntegrator, Class<?> clazz) { DirectoryBasedIndexManager im = (DirectoryBasedIndexManager) searchIntegrator.getIndexBindings().get(clazz) .getIndexManagerSelector().all().iterator().next(); WorkspaceHolder workspaceHolder = im.getWorkspaceHolder(); LuceneBackendResources indexResources = workspaceHolder.getIndexResources(); IndexWorkVisitor<Void, LuceneWorkExecutor> visitor = indexResources.getWorkVisitor(); assertTrue(TestingUtil.extractField(visitor, "updateExecutor") instanceof ByTermUpdateWorkExecutor); } }
public static void assertNoLocks(LockManager lockManager) { LockContainer lc = TestingUtil.extractField(lockManager, "lockContainer"); assertEquals("Stale locks exist! NumLocksHeld is " + lc.getNumLocksHeld() + " and lock info is " + lockManager.printLockInfo(), 0, lc.getNumLocksHeld()); }
public static CountingRequestRepository replaceDispatcher(EmbeddedCacheManager cacheManager) { GlobalComponentRegistry gcr = cacheManager.getGlobalComponentRegistry(); JGroupsTransport transport = (JGroupsTransport) gcr.getComponent(Transport.class); RequestRepository requestRepository = (RequestRepository) TestingUtil.extractField(JGroupsTransport.class, transport, "requests"); CountingRequestRepository instance = new CountingRequestRepository(requestRepository); TestingUtil.replaceField(instance, "requests", transport, JGroupsTransport.class); return instance; }
private void doWhenSourceIterationReaches(String key, TestCluster cluster, String cacheName, IterationCallBack callback) { cluster.getEmbeddedCaches(cacheName).forEach(c -> { PersistenceManager pm = extractComponent(c, PersistenceManager.class); RemoteStore remoteStore = pm.getStores(RemoteStore.class).iterator().next(); RemoteCacheImpl remoteCache = TestingUtil.extractField(remoteStore, "remoteCache"); RemoteCacheImpl spy = spy(remoteCache); doAnswer(invocation -> { Object[] params = invocation.getArguments(); CallbackRemoteIterator<Object> remoteCloseableIterator = new CallbackRemoteIterator<>(spy.getOperationsFactory(), (int) params[1], null, true, spy.getDataFormat()); remoteCloseableIterator.addCallback(callback, key); remoteCloseableIterator.start(); return remoteCloseableIterator; }).when(spy).retrieveEntriesWithMetadata(isNull(), anyInt()); TestingUtil.replaceField(spy, "remoteCache", remoteStore, RemoteStore.class); }); }
private void assertCapacityFactors(float... expectedCapacityFactors) { ConsistentHash ch = cache(0).getAdvancedCache().getDistributionManager().getReadConsistentHash(); DefaultConsistentHash dch = (DefaultConsistentHash) TestingUtil.extractField(PartitionerConsistentHash.class, ch, "ch"); int numNodes = expectedCapacityFactors.length; Map<Address,Float> capacityFactors = dch.getCapacityFactors(); for (int i = 0; i < numNodes; i++) { assertEquals(expectedCapacityFactors[i], capacityFactors.get(address(i)), 0.0); } }
public void testStartSameCache() { final EmbeddedCacheManager cacheManager = manager(0); GlobalComponentRegistry registry = (GlobalComponentRegistry) TestingUtil.extractField(cacheManager, "globalComponentRegistry"); List<ModuleLifecycle> lifecycles = new LinkedList<>(); TestingUtil.replaceField(lifecycles, "moduleLifecycles", registry, GlobalComponentRegistry.class); lifecycles.add(new ModuleLifecycle() { @Override public void cacheStarted(ComponentRegistry cr, String cacheName) { Cache cache = cacheManager.getCache("single"); cache.put("k1", "v1"); } }); Cache<Object, Object> some = cacheManager.getCache("single"); some.put("k2", "v2"); assertEquals("v1", cacheManager.getCache("single").get("k1")); assertEquals("v2", cacheManager.getCache("single").get("k2")); } }
@Override public void call() { Cache<Integer, String> cache = cm.getCache(); AdvancedAsyncCacheWriter asyncStore = TestingUtil.getFirstWriter(cache); DummyInMemoryStore dummyStore = TestingUtil.extractField(asyncStore, "actual"); cache.put(1, "uno"); cache.put(2, "dos"); cache.put(3, "tres"); eventually(new Condition() { @Override public boolean isSatisfied() throws Exception { return dummyStore.size() == 3; } }); cache.clear(); eventually(new Condition() { @Override public boolean isSatisfied() throws Exception { return dummyStore.size() == 0; } }); } });
public void testUnauthorizedOpCloseConnection(Method m) { // Ensure the transport is clean ChannelGroup acceptedChannels = TestingUtil.extractField(server().getTransport(), "acceptedChannels"); acceptedChannels.close().awaitUninterruptibly(); try { client().assertPutFail(m); } finally { assertEquals(0, server().getTransport().getNumberOfLocalConnections()); } } }
@Test public void testWritesFailSilentlyWhenConfigured() { Cache<Object, Object> cache = createManagerAndGetCache(true, 1); AdvancedAsyncCacheWriter asyncWriter = TestingUtil.getFirstWriter(cache); DummyInMemoryStore store = (DummyInMemoryStore) TestingUtil.extractField(AdvancedAsyncCacheWriter.class, asyncWriter, "actual"); assertTrue(store.isAvailable()); cache.put(1, 1); eventually(() -> store.load(1) != null); assertEquals(1, store.size()); store.setAvailable(false); assertFalse(store.isAvailable()); cache.put(1, 2); // Should fail on the store, but complete in-memory TestingUtil.sleepThread(1000); // Sleep to ensure async write is attempted store.setAvailable(true); MarshalledEntry entry = store.load(1); assertNotNull(entry); assertEquals(1, entry.getValue()); assertEquals(2, cache.get(1)); }