content: 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.Closeable;
  import java.io.IOException;
  
  import org.apache.lucene.util.ThreadInterruptedException;
  
  /**
   * Utility class that runs a reopen thread to periodically
   * reopen the NRT searchers in the provided {@link
   * NRTManager}.
   *
   * <p> Typical usage looks like this:
   *
   * <pre>
   *   ... open your own writer ...
   * 
   *   NRTManager manager = new NRTManager(writer);
   *
   *   // Refreshes searcher every 5 seconds when nobody is waiting, and up to 100 msec delay
   *   // when somebody is waiting:
   *   NRTManagerReopenThread reopenThread = new NRTManagerReopenThread(manager, 5.0, 0.1);
   *   reopenThread.setName("NRT Reopen Thread");
   *   reopenThread.setPriority(Math.min(Thread.currentThread().getPriority()+2, Thread.MAX_PRIORITY));
   *   reopenThread.setDaemon(true);
   *   reopenThread.start();
   * </pre>
   *
   * Then, for each incoming query, do this:
   *
   * <pre>
   *   // For each incoming query:
   *   IndexSearcher searcher = manager.get();
   *   try {
   *     // Use searcher to search...
   *   } finally {
   *     manager.release(searcher);
   *   }
   * </pre>
   *
   * You should make changes using the <code>NRTManager</code>; if you later need to obtain
   * a searcher reflecting those changes:
   *
   * <pre>
   *   // ... or updateDocument, deleteDocuments, etc:
   *   long gen = manager.addDocument(...);
   *   
   *   // Returned searcher is guaranteed to reflect the just added document
   *   IndexSearcher searcher = manager.get(gen);
   *   try {
   *     // Use searcher to search...
   *   } finally {
   *     manager.release(searcher);
   *   }
   * </pre>
   *
   *
   * When you are done be sure to close both the manager and the reopen thrad:
   * <pre> 
   *   reopenThread.close();       
   *   manager.close();
   * </pre>
   *
   * @lucene.experimental
   */
  
  public class NRTManagerReopenThread extends Thread implements NRTManager.WaitingListener, Closeable {
    
    private final NRTManager manager;
    private final long targetMaxStaleNS;
    private final long targetMinStaleNS;
    private boolean finish;
    private long waitingGen;
    private boolean waitingNeedsDeletes;
  
    /**
     * Create NRTManagerReopenThread, to periodically reopen the NRT searcher.
     *
     * @param targetMaxStaleSec Maximum time until a new
     *        reader must be opened; this sets the upper bound
     *        on how slowly reopens may occur
     *
     * @param targetMinStaleSec Mininum time until a new
     *        reader can be opened; this sets the lower bound
     *        on how quickly reopens may occur, when a caller
     *        is waiting for a specific indexing change to
     *        become visible.
     */
  
    public NRTManagerReopenThread(NRTManager manager, double targetMaxStaleSec, double targetMinStaleSec) {
      if (targetMaxStaleSec < targetMinStaleSec) {
        throw new IllegalArgumentException("targetMaxScaleSec (= " + targetMaxStaleSec + ") < targetMinStaleSec (=" + targetMinStaleSec + ")");
      }
      this.manager = manager;
      this.targetMaxStaleNS = (long) (1000000000*targetMaxStaleSec);
      this.targetMinStaleNS = (long) (1000000000*targetMinStaleSec);
      manager.addWaitingListener(this);
    }
  
    public synchronized void close() {
      //System.out.println("NRT: set finish");
      manager.removeWaitingListener(this);
      this.finish = true;
      notify();
      try {
        join();
      } catch (InterruptedException ie) {
        throw new ThreadInterruptedException(ie);
      }
    }
  
    public synchronized void waiting(boolean needsDeletes, long targetGen) {
      waitingNeedsDeletes |= needsDeletes;
      waitingGen = Math.max(waitingGen, targetGen);
      notify();
      //System.out.println(Thread.currentThread().getName() + ": force wakeup waitingGen=" + waitingGen + " applyDeletes=" + applyDeletes + " waitingNeedsDeletes=" + waitingNeedsDeletes);
    }
  
    @Override
    public void run() {
      // TODO: maybe use private thread ticktock timer, in
      // case clock shift messes up nanoTime?
      long lastReopenStartNS = System.nanoTime();
  
      //System.out.println("reopen: start");
      try {
        while (true) {
  
          boolean hasWaiting = false;
  
          synchronized(this) {
            // TODO: try to guestimate how long reopen might
            // take based on past data?
  
            while (!finish) {
              //System.out.println("reopen: cycle");
  
              // True if we have someone waiting for reopen'd searcher:
              hasWaiting = waitingGen > manager.getCurrentSearchingGen(waitingNeedsDeletes);
              final long nextReopenStartNS = lastReopenStartNS + (hasWaiting ? targetMinStaleNS : targetMaxStaleNS);
  
              final long sleepNS = nextReopenStartNS - System.nanoTime();
  
              if (sleepNS > 0) {
                //System.out.println("reopen: sleep " + (sleepNS/1000000.0) + " ms (hasWaiting=" + hasWaiting + ")");
                try {
                  wait(sleepNS/1000000, (int) (sleepNS%1000000));
                } catch (InterruptedException ie) {
                  Thread.currentThread().interrupt();
                  //System.out.println("NRT: set finish on interrupt");
                  finish = true;
                  break;
                }
              } else {
                break;
              }
            }
  
            if (finish) {
              //System.out.println("reopen: finish");
              return;
            }
            //System.out.println("reopen: start hasWaiting=" + hasWaiting);
          }
  
          lastReopenStartNS = System.nanoTime();
          try {
            //final long t0 = System.nanoTime();
            manager.maybeReopen(waitingNeedsDeletes);
            //System.out.println("reopen took " + ((System.nanoTime()-t0)/1000000.0) + " msec");
          } catch (IOException ioe) {
            //System.out.println(Thread.currentThread().getName() + ": IOE");
            //ioe.printStackTrace();
            throw new RuntimeException(ioe);
          }
        }
      } catch (Throwable t) {
        //System.out.println("REOPEN EXC");
        //t.printStackTrace(System.out);
        throw new RuntimeException(t);
      }
    }
  }
  