@Test public void testRunningOnMultipleCaches() throws IOException { assert metadataCache != chunkCache; assert chunkCache != lockCache; assert lockCache != metadataCache; String indexName = "testingIndex"; TestSegmentReadLocker testSegmentReadLocker = new TestSegmentReadLocker(lockCache, chunkCache, metadataCache, indexName); Directory dir = DirectoryBuilder.newDirectoryInstance(metadataCache, chunkCache, lockCache, indexName) .overrideSegmentReadLocker(testSegmentReadLocker).chunkSize(100).create(); writeTextToIndex(dir, 0, "hello world"); assertTextIsFoundInIds(dir, "hello", 0); writeTextToIndex(dir, 1, "hello solar system"); assertTextIsFoundInIds(dir, "hello", 0, 1); assertTextIsFoundInIds(dir, "system", 1); optimizeIndex(dir); assertTextIsFoundInIds(dir, "hello", 0, 1); dir.close(); }
public void testInfinispanDirectory() throws Exception { final int OPERATIONS = 100; CacheContainer cacheContainer = CacheTestSupport.createTestCacheManager(); Cache cache = cacheContainer.getCache(); Directory directory = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, "indexName").create(); CacheTestSupport.initializeDirectory(directory); File document = CacheTestSupport.createDummyDocToIndex("document.lucene", 10000); for (int i = 0; i < OPERATIONS; i++) { CacheTestSupport.doWriteOperation(directory, document); CacheTestSupport.doReadOperation(directory); } IndexReader ir = DirectoryReader.open(directory); IndexSearcher search = new IndexSearcher(ir); Term t = new Term("info", "good"); Query query = new TermQuery(t); TopDocs hits = search.search(query, 1); ir.close(); assert OPERATIONS == hits.totalHits; directory.close(); cacheContainer.stop(); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder configurationBuilder = CacheTestSupport.createLocalCacheConfiguration(); return TestCacheManagerFactory.createCacheManager(configurationBuilder); }
private void verifyDir(final Directory dir, final String expectedIndexName) throws IOException { DirectoryExtensions infDir = (DirectoryExtensions) dir; AssertJUnit.assertEquals(expectedIndexName, infDir.getIndexName()); writeTextToIndex(dir, 0, "hi all"); assertTextIsFoundInIds(dir, "hi", 0); writeTextToIndex(dir, 1, "all together"); assertTextIsFoundInIds(dir, "all", 0, 1); } }
@Override public void run() { try { latch.await(); for (int i = 0; i < TURNS_NUM; i++) { if (!isWritingThread) { CacheTestSupport.doReadOperation(dir); } else { writeCount.incrementAndGet(); CacheTestSupport.doWriteOperation(dir, document); } } } catch (Exception ex) { log.error("Error", ex); e = ex; } } }
@Test public void testIndexUsage() throws IOException { cache = cacheManager.getCache(); TestSegmentReadLocker testSegmentReadLocker = new TestSegmentReadLocker(cache, cache, cache, INDEX_NAME); Directory dir = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, INDEX_NAME) .overrideSegmentReadLocker(testSegmentReadLocker).create(); writeTextToIndex(dir, 0, "hello database"); assertTextIsFoundInIds(dir, "hello", 0); writeTextToIndex(dir, 1, "you have to store my index segments"); writeTextToIndex(dir, 2, "so that I can shut down all nodes"); writeTextToIndex(dir, 3, "and restart later keeping the index around"); assertTextIsFoundInIds(dir, "index", 1, 3); removeByTerm(dir, "and"); assertTextIsFoundInIds(dir, "index", 1); dir.close(); for (Map.Entry me : cache.getAdvancedCache().withFlags(Flag.SKIP_CACHE_LOAD).entrySet()) { cacheCopy.put(me.getKey(), me.getValue()); } cache.stop(); cacheManager.stop(); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder configurationBuilder = CacheTestSupport.createTestConfiguration(TransactionMode.NON_TRANSACTIONAL); createClusteredCaches(2, CACHE_NAME, configurationBuilder); }
public void testDirectoryWithMultipleThreads() throws Exception { final CountDownLatch latch = new CountDownLatch(1); List<InfinispanDirectoryThread> threads = new ArrayList<InfinispanDirectoryThread>(); Cache cache = CacheTestSupport.createTestCacheManager().getCache(); Directory directory1 = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, "indexName").create(); CacheTestSupport.initializeDirectory(directory1); Cache cache2 = CacheTestSupport.createTestCacheManager().getCache(); // dummy cache, to force replication Directory directory2 = DirectoryBuilder.newDirectoryInstance(cache2, cache2, cache2, "indexName").create(); Thread.sleep(3000);
@Test(dependsOnMethods="testIndexUsage") public void indexWasStored() throws IOException { cache = cacheManager.getCache(); boolean failed = false; for (Object key : cacheCopy.keySet()) { if (key instanceof FileReadLockKey) { log.error("Key found in store, shouldn't have persisted this or should have cleaned up all readlocks on directory close:" + key); failed = true; } else { Object expected = cacheCopy.get(key); Object actual = cache.get(key); if (expected==null && actual==null) continue; if (expected instanceof byte[]) { expected = Util.printArray((byte[]) expected, false); actual = Util.printArray((byte[]) actual, false); } if (expected == null || ! expected.equals(actual)) { log.error("Failure on key["+key.toString()+"] expected value:\n\t"+expected+"\tactual value:\n\t"+actual); failed = true; } } } AssertJUnit.assertFalse(failed); AssertJUnit.assertEquals("have a different number of keys", cacheCopy.keySet().size(), cache.keySet().size()); Directory dir = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, INDEX_NAME).create(); assertTextIsFoundInIds(dir, "index", 1); dir.close(); }
@Test public void profileInfinispanLocalDirectory() throws InterruptedException, IOException { CacheContainer cacheManager = CacheTestSupport.createLocalCacheManager(); try { Cache cache = cacheManager.getCache(); Directory dir = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, "iname").create(); testDirectory(dir, "InfinispanLocal"); } finally { cacheManager.stop(); } }
protected InfinispanDirectoryThread(CountDownLatch latch, Directory dir, boolean isWritingThread) throws Exception { this.latch = latch; this.dir = dir; this.isWritingThread = isWritingThread; document = CacheTestSupport.createDummyDocToIndex("document.lucene", 10000); }
@BeforeClass(alwaysRun = true) public void prepareCacheManager() { cacheManager = CacheTestSupport.createTestCacheManager(); }
@Test public void testIndexWritingAndFinding() throws IOException { final String indexName = "indexName"; final Cache cache0 = cache(0, "lucene"); final Cache cache1 = cache(1, "lucene"); TestSegmentReadLocker readLocker = new TestSegmentReadLocker(cache0, cache0, cache0, indexName); Directory dirA = DirectoryBuilder.newDirectoryInstance(cache0, cache0, cache0, indexName).overrideSegmentReadLocker(readLocker).create(); Directory dirB = DirectoryBuilder.newDirectoryInstance(cache1, cache1, cache1, indexName).overrideSegmentReadLocker(readLocker).create(); writeTextToIndex(dirA, 0, "hi from node A"); assertTextIsFoundInIds(dirA, "hi", 0); assertTextIsFoundInIds(dirB, "hi", 0); writeTextToIndex(dirB, 1, "hello node A, how are you?"); assertTextIsFoundInIds(dirA, "hello", 1); assertTextIsFoundInIds(dirB, "hello", 1); assertTextIsFoundInIds(dirA, "node", 1, 0); // node is keyword in both documents id=0 and id=1 assertTextIsFoundInIds(dirB, "node", 1, 0); removeByTerm(dirA, "from"); assertTextIsFoundInIds(dirB, "node", 1); dirA.close(); dirB.close(); DirectoryIntegrityCheck.verifyDirectoryStructure(cache0, "indexName"); DirectoryIntegrityCheck.verifyDirectoryStructure(cache1, "indexName"); }
@Test public void testReadingFromDifferentlySizedBuffers() throws IOException { cache = cacheManager.getCache(); Directory dirA = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, "indexName").chunkSize(7).create(); writeTextToIndex(dirA, 0, "hi from node A"); Directory dirB = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, "indexName").chunkSize(8).create(); assertTextIsFoundInIds(dirB, "hi", 0); writeTextToIndex(dirB, 1, "index B is sharing the same index but using a differently sized chunk size"); assertTextIsFoundInIds(dirA, "size", 1); }
protected static CacheContainer createTestCacheManager() { return TestCacheManagerFactory.createClusteredCacheManager( createTestConfiguration(TransactionMode.NON_TRANSACTIONAL)); }
@Test public void profileInfinispanLocalDirectory() throws InterruptedException, IOException { CacheContainer cacheContainer = CacheTestSupport.createLocalCacheManager(); try { Cache cache = cacheContainer.getCache(); Directory dir = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, indexName).chunkSize(CHUNK_SIZE).create(); stressTestDirectoryInternal(dir, dir, "InfinispanLocal"); verifyDirectoryState(); } finally { cacheContainer.stop(); } }
@Test @SuppressWarnings("unchecked") public void testIndexWritingAndFinding() throws IOException { final String indexName = "indexName"; final Cache<?,?> cache0 = cache(0, "lucene"); final Cache<?,?> cache1 = cache(1, "lucene"); TestSegmentReadLocker testSegmentReadLocker = new TestSegmentReadLocker((Cache<Object, Integer>) cache0, cache0, cache0, indexName); Directory dirA = DirectoryBuilder.newDirectoryInstance(cache0, cache0, cache0, indexName).overrideSegmentReadLocker(testSegmentReadLocker).create(); Directory dirB = DirectoryBuilder.newDirectoryInstance(cache1, cache1, cache1, indexName).overrideSegmentReadLocker(testSegmentReadLocker).create(); writeTextToIndex(dirA, 0, "hi from node A"); assertTextIsFoundInIds(dirA, "hi", 0); assertTextIsFoundInIds(dirB, "hi", 0); writeTextToIndex(dirB, 1, "hello node A, how are you?"); assertTextIsFoundInIds(dirA, "hello", 1); assertTextIsFoundInIds(dirB, "hello", 1); assertTextIsFoundInIds(dirA, "node", 1, 0); // node is keyword in both documents id=0 and id=1 assertTextIsFoundInIds(dirB, "node", 1, 0); removeByTerm(dirA, "from"); assertTextIsFoundInIds(dirB, "node", 1); dirA.close(); dirB.close(); DirectoryIntegrityCheck.verifyDirectoryStructure(cache0, "indexName"); DirectoryIntegrityCheck.verifyDirectoryStructure(cache1, "indexName"); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder configuration = CacheTestSupport.createLocalCacheConfiguration(); return TestCacheManagerFactory.createCacheManager(configuration); }
protected void createCacheManagers() throws Throwable { ConfigurationBuilder configurationBuilder = CacheTestSupport.createTestConfiguration(getTransactionsMode()); createClusteredCaches(2, "lucene", configurationBuilder); }
@BeforeClass public void createBeforeClass() { cacheManager = CacheTestSupport.createLocalCacheManager(); cacheManager.defineConfiguration("metadata", cacheManager.getDefaultCacheConfiguration()); metadataCache = cacheManager.getCache("metadata"); cacheManager.defineConfiguration("chunks", cacheManager.getDefaultCacheConfiguration()); chunkCache = cacheManager.getCache("chunks"); cacheManager.defineConfiguration("locks", cacheManager.getDefaultCacheConfiguration()); lockCache = cacheManager.getCache("locks"); }