NearRealtimeReaderTask.java

package org.apache.lucene.benchmark.byTask.tasks;

/**
 * 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 org.apache.lucene.benchmark.byTask.PerfRunData;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.SortField;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.TopFieldDocs;
import org.apache.lucene.index.Term;

/**
 * Spawns a BG thread that periodically (defaults to 3.0
 * seconds, but accepts param in seconds) wakes up and asks
 * IndexWriter for a near real-time reader.  Then runs a
 * single query (body: 1) sorted by docdate, and prints
 * time to reopen and time to run the search.
 *
 * <b>NOTE</b>: this is very experimental at this point, and
 * subject to change.  It's also not generally usable, eg
 * you cannot change which query is executed.
 */
public class NearRealtimeReaderTask extends PerfTask {

  ReopenThread t;
  float pauseSec = 3.0f;

  private static class ReopenThread extends Thread {

    final IndexWriter writer;
    final int pauseMsec;

    public volatile boolean done;

    ReopenThread(IndexWriter writer, float pauseSec) {
      this.writer = writer;
      this.pauseMsec = (int) (1000*pauseSec);
      setDaemon(true);
    }

    public void run() {

      IndexReader reader = null;

      final Query query = new TermQuery(new Term("body", "1"));
      final SortField sf = new SortField("docdate", SortField.LONG);
      final Sort sort = new Sort(sf);

      try {
        while(!done) {
          final long t0 = System.currentTimeMillis();
          if (reader == null) {
            reader = writer.getReader();
          } else {
            final IndexReader newReader = reader.reopen();
            if (reader != newReader) {
              reader.close();
              reader = newReader;
            }
          }

          final long t1 = System.currentTimeMillis();
          final TopFieldDocs hits = new IndexSearcher(reader).search(query, null, 10, sort);
          final long t2 = System.currentTimeMillis();
          System.out.println("nrt: open " + (t1-t0) + " msec; search " + (t2-t1) + " msec, " + hits.totalHits +
                             " results; " + reader.numDocs() + " docs");

          final long t4 = System.currentTimeMillis();
          final int delay = (int) (pauseMsec - (t4-t0));
          if (delay > 0) {
            try {
              Thread.sleep(delay);
            } catch (InterruptedException ie) {
              throw new RuntimeException(ie);
            }
          }
        }
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    }
  }

  public NearRealtimeReaderTask(PerfRunData runData) {
    super(runData);
  }

  public int doLogic() throws IOException {
    if (t == null) {
      IndexWriter w = getRunData().getIndexWriter();
      t = new ReopenThread(w, pauseSec);
      t.start();
    }
    return 1;
  }

  public void setParams(String params) {
    super.setParams(params);
    pauseSec = Float.parseFloat(params);
  }

  public boolean supportsParams() {
    return true;
  }

  // Close the thread
  public void close() throws InterruptedException {
    if (t != null) {
      t.done = true;
      t.join();
    }
  }
}