public static void createIndex(Cache cache, String... fieldNames) { final LuceneIndexFactory indexFactory = LuceneServiceProvider.get(cache).createIndexFactory(); indexFactory.setFields(fieldNames).create(INDEX_NAME, REGION_NAME); }
@Before public void createCache() { CacheFactory cf = getCacheFactory(); this.cache = cf.create(); luceneService = LuceneServiceProvider.get(this.cache); }
public static void verifyIndexFinishFlushing(Cache cache, String indexName, String regionName) throws InterruptedException { LuceneService luceneService = LuceneServiceProvider.get(cache); LuceneIndex index = luceneService.getIndex(indexName, regionName); boolean flushed = luceneService.waitUntilFlushed(indexName, regionName, 60000, TimeUnit.MILLISECONDS); assertTrue(flushed); }
@Override public void beforeCreate(Extensible<Region<?, ?>> source, Cache cache) { LuceneServiceImpl service = (LuceneServiceImpl) LuceneServiceProvider.get(cache); Analyzer analyzer = this.fieldAnalyzers == null ? new StandardAnalyzer() : new PerFieldAnalyzerWrapper(new StandardAnalyzer(), this.fieldAnalyzers); try { service.createIndex(getName(), getRegionPath(), analyzer, this.fieldAnalyzers, getLuceneSerializer(), false, getFieldNames()); } catch (LuceneIndexExistsException e) { logger .info(String.format("Ignoring duplicate index creation for Lucene index %s on region %s", e.getIndexName(), e.getRegionPath())); } }
LuceneServiceImpl impl = (LuceneServiceImpl) LuceneServiceProvider.get(cache); try { impl.destroyIndex(this.indexName, this.regionPath, false);
@Override public void execute(final FunctionContext context) { final Set<LuceneIndexDetails> indexDetailsSet = new HashSet<>(); final Cache cache = context.getCache(); final String serverName = cache.getDistributedSystem().getDistributedMember().getName(); LuceneServiceImpl service = (LuceneServiceImpl) LuceneServiceProvider.get(cache); for (LuceneIndexCreationProfile profile : service.getAllDefinedIndexes()) { indexDetailsSet .add(new LuceneIndexDetails(profile, serverName, LuceneIndexStatus.NOT_INITIALIZED)); } for (LuceneIndex index : service.getAllIndexes()) { LuceneIndexStatus initialized; if (index.isIndexingInProgress()) { initialized = LuceneIndexStatus.INDEXING_IN_PROGRESS; } else { initialized = LuceneIndexStatus.INITIALIZED; } indexDetailsSet.add(new LuceneIndexDetails((LuceneIndexImpl) index, serverName, initialized)); } context.getResultSender().lastResult(indexDetailsSet); } }
LuceneService service = LuceneServiceProvider.get(ctx.getDataSet().getCache()); InternalLuceneIndex index = (InternalLuceneIndex) service.getIndex(indexName, region.getFullPath());
@Override public void execute(FunctionContext<Object> context) { RegionFunctionContext ctx = (RegionFunctionContext) context; ResultSender<Boolean> resultSender = ctx.getResultSender(); Region region = ctx.getDataSet(); Cache cache = region.getCache(); String indexName = (String) ctx.getArguments(); if (indexName == null) { throw new IllegalArgumentException("Missing index name"); } LuceneService luceneService = LuceneServiceProvider.get(cache); LuceneIndex luceneIndex = luceneService.getIndex(indexName, region.getFullPath()); if (luceneIndex == null) { resultSender.lastResult(false); } else { resultSender.lastResult(luceneIndex.isIndexingInProgress()); } }
final LuceneQueryInfo queryInfo = (LuceneQueryInfo) context.getArguments(); LuceneService luceneService = LuceneServiceProvider.get(context.getCache()); try { if (luceneService.getIndex(queryInfo.getIndexName(), queryInfo.getRegionPath()) == null) {
LuceneService service = LuceneServiceProvider.get(cache);
private InternalLuceneIndex getLuceneIndex(final Region region, final LuceneFunctionContext<IndexResultCollector> searchContext) { LuceneService service = LuceneServiceProvider.get(region.getCache()); InternalLuceneIndex index = null; try { index = (InternalLuceneIndex) service.getIndex(searchContext.getIndexName(), region.getFullPath()); if (index == null) { while (service instanceof LuceneServiceImpl && (((LuceneServiceImpl) service) .getDefinedIndex(searchContext.getIndexName(), region.getFullPath()) != null)) { try { Thread.sleep(10); } catch (InterruptedException e) { return null; } region.getCache().getCancelCriterion().checkCancelInProgress(null); } index = (InternalLuceneIndex) service.getIndex(searchContext.getIndexName(), region.getFullPath()); } } catch (CacheClosedException e) { throw new InternalFunctionInvocationTargetException( "Cache is closed when attempting to retrieve index:" + region.getFullPath(), e); } return index; }
@Override public void execute(final FunctionContext context) { LuceneIndexDetails result = null; final Cache cache = context.getCache(); final String serverName = cache.getDistributedSystem().getDistributedMember().getName(); final LuceneIndexInfo indexInfo = (LuceneIndexInfo) context.getArguments(); LuceneServiceImpl service = (LuceneServiceImpl) LuceneServiceProvider.get(cache); LuceneIndex index = service.getIndex(indexInfo.getIndexName(), indexInfo.getRegionPath()); LuceneIndexCreationProfile profile = service.getDefinedIndex(indexInfo.getIndexName(), indexInfo.getRegionPath()); if (index != null) { result = new LuceneIndexDetails((LuceneIndexImpl) index, serverName); } else if (profile != null) { result = new LuceneIndexDetails(profile, serverName); } context.getResultSender().lastResult(result); } }
String indexName = indexInfo.getIndexName(); String regionPath = indexInfo.getRegionPath(); LuceneService service = LuceneServiceProvider.get(context.getCache()); if (indexName == null) { if (indexInfo.isDefinedDestroyOnly()) {
/** * Attempts to resolve the Singleton instance of the {@link GemFireCache} {@link LuceneService} * from given the {@link GemFireCache}. * * @param gemFireCache {@link GemFireCache} used to resolve the {@link LuceneService} instance. * @return a single instance of the GemFire {@link LuceneService}. * @see org.apache.geode.cache.GemFireCache * @see org.apache.geode.cache.lucene.LuceneService */ protected LuceneService resolveLuceneService(GemFireCache gemFireCache) { return LuceneServiceProvider.get(gemfireCache); }
/** * Attempts to resolve the Singleton instance of the {@link GemFireCache} {@link LuceneService} * from given the {@link GemFireCache}. * * @param gemFireCache {@link GemFireCache} used to resolve the {@link LuceneService} instance. * @return a single instance of the Pivotal GemFire {@link LuceneService}. * @see org.apache.geode.cache.GemFireCache * @see org.apache.geode.cache.lucene.LuceneService */ protected LuceneService resolveLuceneService(GemFireCache gemFireCache) { return LuceneServiceProvider.get(gemfireCache); }
/** * Resolves the {@link LuceneService} used by this data access object to perform Lucene queries. * * @param gemfireCache {@link GemFireCache} used to resolve the {@link LuceneService}. * @return a reference to the {@link GemFireCache} {@link LuceneService}. * @throws IllegalArgumentException if {@link GemFireCache} is {@literal null}. * @see org.apache.geode.cache.lucene.LuceneService * @see org.apache.geode.cache.GemFireCache */ protected LuceneService resolveLuceneService(GemFireCache gemfireCache) { Assert.notNull(gemfireCache, "Cache reference was not properly configured"); return LuceneServiceProvider.get(gemfireCache); }
/** * Resolves the {@link LuceneService} used by this {@link FactoryBean} to create the {@link LuceneIndex}. * * @param gemfireCache {@link GemFireCache} used to resolve the {@link LuceneService}. * @return a reference to the {@link GemFireCache} {@link LuceneService}. * @throws IllegalArgumentException if {@link GemFireCache} is {@literal null}. * @see org.apache.geode.cache.lucene.LuceneService * @see org.apache.geode.cache.GemFireCache */ protected LuceneService resolveLuceneService(GemFireCache gemfireCache) { Assert.notNull(gemfireCache, "A reference to the GemFireCache was not properly configured"); return LuceneServiceProvider.get(gemfireCache); }
/** * Resolves the {@link LuceneService} used by this data access object to perform Lucene queries. * * @param gemfireCache {@link GemFireCache} used to resolve the {@link LuceneService}. * @return a reference to the {@link GemFireCache} {@link LuceneService}. * @throws IllegalArgumentException if {@link GemFireCache} is {@literal null}. * @see org.apache.geode.cache.lucene.LuceneService * @see org.apache.geode.cache.GemFireCache */ protected LuceneService resolveLuceneService(GemFireCache gemfireCache) { Assert.notNull(gemfireCache, "Cache reference was not properly configured"); return LuceneServiceProvider.get(gemfireCache); }
/** * Resolves the {@link LuceneService} used by this {@link FactoryBean} to create the {@link LuceneIndex}. * * @param gemfireCache {@link GemFireCache} used to resolve the {@link LuceneService}. * @return a reference to the {@link GemFireCache} {@link LuceneService}. * @throws IllegalArgumentException if {@link GemFireCache} is {@literal null}. * @see org.apache.geode.cache.lucene.LuceneService * @see org.apache.geode.cache.GemFireCache */ protected LuceneService resolveLuceneService(GemFireCache gemfireCache) { Assert.notNull(gemfireCache, "A reference to the GemFireCache was not properly configured"); return LuceneServiceProvider.get(gemfireCache); }
private static void query(ClientCache cache) throws LuceneQueryException { LuceneService lucene = LuceneServiceProvider.get(cache); LuceneQuery<Integer, EmployeeData> query = lucene.createLuceneQueryFactory() .create(SIMPLE_INDEX, EXAMPLE_REGION, "firstName:Chris~2", "firstname"); System.out.println("Employees with first names like Chris: " + query.findValues()); }