public void testLoadAllKeysWithExclusionOfRootKey() throws Exception { TestHelper.createIndex(rootDir, indexName, elementCount, true); LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); Set keySet = PersistenceUtil.toKeySet(cacheLoader, null); int initialCount = keySet.size(); HashSet exclusionSet = new HashSet(); exclusionSet.add(new FileListCacheKey(indexName, segmentId)); keySet = PersistenceUtil.toKeySet(cacheLoader, k -> !exclusionSet.contains(k)); String[] fileNamesArr = TestHelper.getFileNamesFromDir(rootDir, indexName); AssertJUnit.assertEquals((initialCount - 1), keySet.size()); Iterator it = keySet.iterator(); while (it.hasNext()) { assert !(it.next() instanceof FileListCacheKey); } }
@BeforeMethod public void setUp() { rootDir = TestHelper.createRootDir(parentDir, getIndexPathName()); }
@Test public void testReadExistingIndex() throws IOException { TestHelper.createIndex(rootDir, "index-A", 10 * SCALE, true); TestHelper.createIndex(rootDir, "index-B", 20 * SCALE, false); TestHelper.verifyIndex(rootDir, "index-A", 10 * SCALE, true); verifyDirectory(rootDir, "index-A", 10 * SCALE, true); TestHelper.verifyIndex(rootDir, "index-B", 20 * SCALE, false); verifyDirectory(rootDir, "index-B", 20 * SCALE, false); }
public void testContainsKeyWithNoExistentRootDir() throws IOException { Directory directory = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, indexName).create(); TestHelper.createIndex(rootDir, indexName, elementCount, true); TestHelper.verifyOnDirectory(directory, elementCount, true); String[] fileNamesFromIndexDir = TestHelper.getFileNamesFromDir(rootDir, indexName); LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); for(String fileName : fileNamesFromIndexDir) { FileCacheKey key = new FileCacheKey(indexName, fileName, segmentId); assert cacheLoader.contains(key); //Testing non-existent keys with non-acceptable type assert !cacheLoader.contains(fileName); } }
/** * Verifies that entries exist/not exist in the index. * * @param rootDir index root directory. * @param indexName index name. * @param termsAdded number of terms to be verified. * @param inverted flag to define which term should exist which not. * @throws IOException */ public static void verifyIndex(File rootDir, String indexName, int termsAdded, boolean inverted) throws IOException { File indexDir = new File(rootDir, indexName); Directory directory = FSDirectory.open(indexDir.toPath()); try { verifyOnDirectory(directory, termsAdded, inverted); } finally { directory.close(); } }
public void testLoadKeyWithInnerNonReadableDir() throws Exception { TestHelper.createIndex(rootDir, indexName, elementCount, true); File innerDir = new File(rootDir.getAbsoluteFile(), "index-B"); try { boolean created = innerDir.mkdir(); assert created; boolean isReadoff = innerDir.setReadable(false); boolean isWriteoff = innerDir.setWritable(false); if (isReadoff && isWriteoff) { LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); cacheLoader.load(5); } else { log.info("Skipping test because it is not possible to make the directory non-readable, i.e. because the tests are run with the root user."); } } catch(Exception ex) { assert ex instanceof PersistenceException; } finally { innerDir.setReadable(true); innerDir.setWritable(true); } }
@Override public void call() throws Exception { Cache cache = cacheManager.getCache(); Directory directory = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, indexName).create(); TestHelper.createIndex(rootDir, indexName, elementCount, true); TestHelper.verifyOnDirectory(directory, elementCount, true); String[] fileNamesFromIndexDir = TestHelper.getFileNamesFromDir(rootDir, indexName); LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); for(String fileName : fileNamesFromIndexDir) { FileCacheKey key = new FileCacheKey(indexName, fileName, -1); assert cacheLoader.contains(key); //Testing non-existent keys with non-acceptable type assert !cacheLoader.contains(fileName); } } });
@Override public void call() throws IOException { Cache<Object, Object> cache = cacheManager.getCache(); Directory directory = DirectoryBuilder.newDirectoryInstance(cache, cache, cache, indexName).create(); TestHelper.verifyOnDirectory(directory, termsAdded, inverted); } });
@Override protected void createCacheManagers() throws Throwable { indexDir = Files.createTempDirectory("test-").toFile(); createIndex(indexDir, INDEX_NAME, TERMS_NUMBER, false); ConfigurationBuilder c = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false); c.clustering().hash().numOwners(1); c.jmxStatistics().enable(); c.persistence() .addStore(LuceneLoaderConfigurationBuilder.class) .preload(true) .location(indexDir.getAbsolutePath()); createCluster(c, CLUSTER_SIZE); waitForClusterToForm(); }
public void testLoadAllKeysWithExclusion() throws Exception { TestHelper.createIndex(rootDir, indexName, elementCount, true); String[] fileNamesFromIndexDir = TestHelper.getFileNamesFromDir(rootDir, indexName); LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); Set keyList = PersistenceUtil.toKeySet(cacheLoader, null); int initialCount = keyList.size(); HashSet exclusionSet = new HashSet(); for(String fileName : fileNamesFromIndexDir) { FileCacheKey key = new FileCacheKey(indexName, fileName, segmentId); AssertJUnit.assertNotNull(cacheLoader.load(key)); exclusionSet.add(key); } keyList = PersistenceUtil.toKeySet(cacheLoader, k -> !exclusionSet.contains(k)); AssertJUnit.assertEquals((initialCount - fileNamesFromIndexDir.length), keyList.size()); Iterator it = keyList.iterator(); if(it.hasNext()) { assert !(it.next() instanceof FileCacheKey); } }
public void testLoadAllKeysWithChunkExclusion() throws Exception { TestHelper.createIndex(rootDir, indexName, elementCount, true); LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); HashSet exclusionSet = new HashSet(); String[] fileNames = TestHelper.getFileNamesFromDir(rootDir, indexName); for(String fileName : fileNames) { exclusionSet.add(new ChunkCacheKey(indexName, fileName, 0, 110, segmentId)); } Set keyList = PersistenceUtil.toKeySet(cacheLoader, null); checkIfExists(keyList, exclusionSet, true, false); keyList = PersistenceUtil.toKeySet(cacheLoader, k -> !exclusionSet.contains(k)); checkIfExists(keyList, exclusionSet, false, true); }
@Test public void testLoadAllKeysWithNullExclusion() throws Exception { TestHelper.createIndex(rootDir, indexName, elementCount, true); String[] fileNamesFromIndexDir = TestHelper.getFileNamesFromDir(rootDir, indexName); LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); Set keyList = PersistenceUtil.toKeySet(cacheLoader, null); for(String fileName : fileNamesFromIndexDir) { FileCacheKey key = new FileCacheKey(indexName, fileName, segmentId); AssertJUnit.assertNotNull(cacheLoader.load(key)); boolean found = false; for(Object keyFromList : keyList) { if(keyFromList instanceof FileCacheKey && keyFromList.equals(key)) { found = true; break; } } assert found : "No corresponding key was found for " + key; } }
public void testLoadAllKeys() throws Exception { TestHelper.createIndex(rootDir, indexName, elementCount, true); String[] fileNamesFromIndexDir = TestHelper.getFileNamesFromDir(rootDir, indexName); LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); Set keyList = PersistenceUtil.toKeySet(cacheLoader, null); for(String fileName : fileNamesFromIndexDir) { FileCacheKey key = new FileCacheKey(indexName, fileName, segmentId); AssertJUnit.assertNotNull(cacheLoader.load(key)); boolean found = false; for(Object keyFromList : keyList) { if(keyFromList instanceof FileCacheKey && keyFromList.equals(key)) { found = true; break; } } assert found : "No corresponding key was found for " + key; } }
public void testLoadKey() throws Exception { TestHelper.createIndex(rootDir, indexName, elementCount, true); String[] fileNamesFromIndexDir = TestHelper.getFileNamesFromDir(rootDir, indexName); LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); for(String fileName : fileNamesFromIndexDir) { FileCacheKey key = new FileCacheKey(indexName, fileName, segmentId); AssertJUnit.assertNotNull(cacheLoader.load(key)); //Testing non-existent keys with non-acceptable type AssertJUnit.assertNull(cacheLoader.load(fileName)); } }
public void testContainsKeyCacheKeyTypes() throws Exception { TestHelper.createIndex(rootDir, indexName, elementCount, true); LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); assert cacheLoader.contains(new FileListCacheKey(indexName, segmentId)); String[] fileNamesFromIndexDir = TestHelper.getFileNamesFromDir(rootDir, indexName); for(String fileName : fileNamesFromIndexDir) { assert !cacheLoader.contains(new FileReadLockKey(indexName, fileName, segmentId)) : "Failed for " + fileName; assert cacheLoader.contains(new ChunkCacheKey(indexName, fileName, 0, 1024, segmentId)) : "Failed for " + fileName; } assert !cacheLoader.contains(new ChunkCacheKey(indexName, "testFile.txt", 0, 1024, segmentId)); }
public void testLoadEntries() throws Exception { TestHelper.createIndex(rootDir, indexName, elementCount, true); String[] fileNamesFromIndexDir = TestHelper.getFileNamesFromDir(rootDir, indexName); LuceneCacheLoader cacheLoader = (LuceneCacheLoader) TestingUtil.getFirstLoader(cacheManager.getCache()); Set<InternalCacheEntry> loadedEntrySet = PersistenceUtil.toEntrySet(cacheLoader, null, cache.getAdvancedCache().getComponentRegistry().getComponent(InternalEntryFactory.class)); for (String fileName : fileNamesFromIndexDir) { FileCacheKey key = new FileCacheKey(indexName, fileName, segmentId); AssertJUnit.assertNotNull(cacheLoader.load(key)); boolean found = false; for (InternalCacheEntry entry : loadedEntrySet) { FileCacheKey keyFromLoad = null; if (entry.getKey() instanceof FileCacheKey) { keyFromLoad = (FileCacheKey) entry.getKey(); if (keyFromLoad != null && keyFromLoad.equals(key)) { found = true; break; } } } assert found : "No corresponding entry found for " + key; } }