--- /dev/null
+package org.apache.lucene.search;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.lucene.analysis.MockAnalyzer;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.index.ConcurrentMergeScheduler;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.index.ThreadedIndexingAndSearchingTestCase;
+import org.apache.lucene.store.AlreadyClosedException;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.NamedThreadFactory;
+import org.apache.lucene.util._TestUtil;
+
+public class TestSearcherManager extends ThreadedIndexingAndSearchingTestCase {
+
+ boolean warmCalled;
+
+ private SearcherLifetimeManager.Pruner pruner;
+
+ public void testSearcherManager() throws Exception {
+ pruner = new SearcherLifetimeManager.PruneByAge(TEST_NIGHTLY ? _TestUtil.nextInt(random, 1, 20) : 1);
+ runTest("TestSearcherManager");
+ }
+
+ @Override
+ protected IndexSearcher getFinalSearcher() throws Exception {
+ if (!isNRT) {
+ writer.commit();
+ }
+ assertTrue(mgr.maybeReopen() || mgr.isSearcherCurrent());
+ return mgr.acquire();
+ }
+
+ private SearcherManager mgr;
+ private SearcherLifetimeManager lifetimeMGR;
+ private final List<Long> pastSearchers = new ArrayList<Long>();
+ private boolean isNRT;
+
+ @Override
+ protected void doAfterWriter(ExecutorService es) throws Exception {
+ final SearcherWarmer warmer = new SearcherWarmer() {
+ public void warm(IndexSearcher s) throws IOException {
+ TestSearcherManager.this.warmCalled = true;
+ s.search(new TermQuery(new Term("body", "united")), 10);
+ }
+ };
+ if (random.nextBoolean()) {
+ // TODO: can we randomize the applyAllDeletes? But
+ // somehow for final searcher we must apply
+ // deletes...
+ mgr = new SearcherManager(writer, true, warmer, es);
+ isNRT = true;
+ } else {
+ // SearcherManager needs to see empty commit:
+ writer.commit();
+ mgr = new SearcherManager(dir, warmer, es);
+ isNRT = false;
+ }
+
+ lifetimeMGR = new SearcherLifetimeManager();
+ }
+
+ @Override
+ protected void doSearching(ExecutorService es, final long stopTime) throws Exception {
+
+ Thread reopenThread = new Thread() {
+ @Override
+ public void run() {
+ try {
+ while(System.currentTimeMillis() < stopTime) {
+ Thread.sleep(_TestUtil.nextInt(random, 1, 100));
+ writer.commit();
+ Thread.sleep(_TestUtil.nextInt(random, 1, 5));
+ if (mgr.maybeReopen()) {
+ lifetimeMGR.prune(pruner);
+ }
+ }
+ } catch (Throwable t) {
+ System.out.println("TEST: reopen thread hit exc");
+ t.printStackTrace(System.out);
+ failed.set(true);
+ throw new RuntimeException(t);
+ }
+ }
+ };
+ reopenThread.setDaemon(true);
+ reopenThread.start();
+
+ runSearchThreads(stopTime);
+
+ reopenThread.join();
+ }
+
+ @Override
+ protected IndexSearcher getCurrentSearcher() throws Exception {
+ if (random.nextInt(10) == 7) {
+ // NOTE: not best practice to call maybeReopen
+ // synchronous to your search threads, but still we
+ // test as apps will presumably do this for
+ // simplicity:
+ if (mgr.maybeReopen()) {
+ lifetimeMGR.prune(pruner);
+ }
+ }
+
+ IndexSearcher s = null;
+
+ synchronized(pastSearchers) {
+ while (pastSearchers.size() != 0 && random.nextDouble() < 0.25) {
+ // 1/4 of the time pull an old searcher, ie, simulate
+ // a user doing a follow-on action on a previous
+ // search (drilling down/up, clicking next/prev page,
+ // etc.)
+ final Long token = pastSearchers.get(random.nextInt(pastSearchers.size()));
+ s = lifetimeMGR.acquire(token);
+ if (s == null) {
+ // Searcher was pruned
+ pastSearchers.remove(token);
+ } else {
+ break;
+ }
+ }
+ }
+
+ if (s == null) {
+ s = mgr.acquire();
+ if (s.getIndexReader().numDocs() != 0) {
+ Long token = lifetimeMGR.record(s);
+ synchronized(pastSearchers) {
+ if (!pastSearchers.contains(token)) {
+ pastSearchers.add(token);
+ }
+ }
+ }
+ }
+
+ return s;
+ }
+
+ @Override
+ protected void releaseSearcher(IndexSearcher s) throws Exception {
+ s.getIndexReader().decRef();
+ }
+
+ @Override
+ protected void doClose() throws Exception {
+ assertTrue(warmCalled);
+ if (VERBOSE) {
+ System.out.println("TEST: now close SearcherManager");
+ }
+ mgr.close();
+ lifetimeMGR.close();
+ }
+
+ public void testIntermediateClose() throws IOException, InterruptedException {
+ Directory dir = newDirectory();
+ // Test can deadlock if we use SMS:
+ IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(
+ TEST_VERSION_CURRENT, new MockAnalyzer(random)).setMergeScheduler(new ConcurrentMergeScheduler()));
+ writer.addDocument(new Document());
+ writer.commit();
+ final CountDownLatch awaitEnterWarm = new CountDownLatch(1);
+ final CountDownLatch awaitClose = new CountDownLatch(1);
+ final ExecutorService es = random.nextBoolean() ? null : Executors.newCachedThreadPool(new NamedThreadFactory("testIntermediateClose"));
+ final SearcherWarmer warmer = new SearcherWarmer() {
+ public void warm(IndexSearcher s) throws IOException {
+ try {
+ awaitEnterWarm.countDown();
+ awaitClose.await();
+ } catch (InterruptedException e) {
+ //
+ }
+ }
+ };
+ final SearcherManager searcherManager = random.nextBoolean() ? new SearcherManager(dir,
+ warmer, es) : new SearcherManager(writer, random.nextBoolean(), warmer, es);
+ IndexSearcher searcher = searcherManager.acquire();
+ try {
+ assertEquals(1, searcher.getIndexReader().numDocs());
+ } finally {
+ searcherManager.release(searcher);
+ }
+ writer.addDocument(new Document());
+ writer.commit();
+ final AtomicBoolean success = new AtomicBoolean(false);
+ final AtomicBoolean triedReopen = new AtomicBoolean(false);
+ final Throwable[] exc = new Throwable[1];
+ Thread thread = new Thread(new Runnable() {
+ //@Override - not on java 5
+ public void run() {
+ try {
+ triedReopen.set(true);
+ searcherManager.maybeReopen();
+ success.set(true);
+ } catch (AlreadyClosedException e) {
+ // expected
+ } catch (Throwable e) {
+ exc[0] = e;
+ // use success as the barrier here to make sure we see the write
+ success.set(false);
+
+ }
+ }
+ });
+ thread.start();
+ awaitEnterWarm.await();
+ for (int i = 0; i < 2; i++) {
+ searcherManager.close();
+ }
+ awaitClose.countDown();
+ thread.join();
+ try {
+ searcherManager.acquire();
+ fail("already closed");
+ } catch (AlreadyClosedException ex) {
+ // expected
+ }
+ assertFalse(success.get());
+ assertTrue(triedReopen.get());
+ assertNull("" + exc[0], exc[0]);
+ writer.close();
+ dir.close();
+ if (es != null) {
+ es.shutdown();
+ es.awaitTermination(1, TimeUnit.SECONDS);
+ }
+ }
+}
fnp / pylucene.git / blobdiff