package org.apache.lucene.index;/** * 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 org.apache.lucene.store.Directory;import org.apache.lucene.store.IndexInput;import org.apache.lucene.store.IndexOutput;import org.apache.lucene.store.ChecksumIndexOutput;import org.apache.lucene.store.ChecksumIndexInput;import java.io.File;import java.io.FileNotFoundException;import java.io.IOException;import java.io.PrintStream;import java.util.Vector;final class SegmentInfos extends Vector {  /** The file format version, a negative number. */  /* Works since counter, the old 1st entry, is always >= 0 */  public static final int FORMAT = -1;  /** This format adds details used for lockless commits.  It differs   * slightly from the previous format in that file names   * are never re-used (write once).  Instead, each file is   * written to the next generation.  For example,   * segments_1, segments_2, etc.  This allows us to not use   * a commit lock.  See <a   * href="http://lucene.apache.org/java/docs/fileformats.html">file   * formats</a> for details.   */  public static final int FORMAT_LOCKLESS = -2;  /** This format adds a "hasSingleNormFile" flag into each segment info.   * See <a href="http://issues.apache.org/jira/browse/LUCENE-756">LUCENE-756</a>   * for details.   */  public static final int FORMAT_SINGLE_NORM_FILE = -3;  /** This format allows multiple segments to share a single   * vectors and stored fields file. */  public static final int FORMAT_SHARED_DOC_STORE = -4;  /** This format adds a checksum at the end of the file to   *  ensure all bytes were successfully written. */  public static final int FORMAT_CHECKSUM = -5;  /** This format adds the deletion count for each segment.   *  This way IndexWriter can efficiently report numDocs(). */  public static final int FORMAT_DEL_COUNT = -6;  /** This format adds the boolean hasProx to record if any   *  fields in the segment store prox information (ie, have   *  omitTf==false) */  public static final int FORMAT_HAS_PROX = -7;  /* This must always point to the most recent file format. */  static final int CURRENT_FORMAT = FORMAT_HAS_PROX;    public int counter = 0;    // used to name new segments  /**   * counts how often the index has been changed by adding or deleting docs.   * starting with the current time in milliseconds forces to create unique version numbers.   */  private long version = System.currentTimeMillis();  private long generation = 0;     // generation of the "segments_N" for the next commit  private long lastGeneration = 0; // generation of the "segments_N" file we last successfully read                                   // or wrote; this is normally the same as generation except if                                   // there was an IOException that had interrupted a commit  /**   * If non-null, information about loading segments_N files   * will be printed here.  @see #setInfoStream.   */  private static PrintStream infoStream;  public final SegmentInfo info(int i) {    return (SegmentInfo) get(i);  }  /**   * Get the generation (N) of the current segments_N file   * from a list of files.   *   * @param files -- array of file names to check   */  public static long getCurrentSegmentGeneration(String[] files) {    if (files == null) {      return -1;    }    long max = -1;    for (int i = 0; i < files.length; i++) {      String file = files[i];      if (file.startsWith(IndexFileNames.SEGMENTS) && !file.equals(IndexFileNames.SEGMENTS_GEN)) {        long gen = generationFromSegmentsFileName(file);        if (gen > max) {          max = gen;        }      }    }    return max;  }  /**   * Get the generation (N) of the current segments_N file   * in the directory.   *   * @param directory -- directory to search for the latest segments_N file   */  public static long getCurrentSegmentGeneration(Directory directory) throws IOException {    String[] files = directory.list();    if (files == null)      throw new IOException("cannot read directory " + directory + ": list() returned null");    return getCurrentSegmentGeneration(files);  }  /**   * Get the filename of the current segments_N file   * from a list of files.   *   * @param files -- array of file names to check   */  public static String getCurrentSegmentFileName(String[] files) throws IOException {    return IndexFileNames.fileNameFromGeneration(IndexFileNames.SEGMENTS,                                                 "",                                                 getCurrentSegmentGeneration(files));  }  /**   * Get the filename of the current segments_N file   * in the directory.   *   * @param directory -- directory to search for the latest segments_N file   */  public static String getCurrentSegmentFileName(Directory directory) throws IOException {    return IndexFileNames.fileNameFromGeneration(IndexFileNames.SEGMENTS,                                                 "",                                                 getCurrentSegmentGeneration(directory));  }  /**   * Get the segments_N filename in use by this segment infos.   */  public String getCurrentSegmentFileName() {    return IndexFileNames.fileNameFromGeneration(IndexFileNames.SEGMENTS,                                                 "",                                                 lastGeneration);  }  /**   * Parse the generation off the segments file name and   * return it.   */  public static long generationFromSegmentsFileName(String fileName) {    if (fileName.equals(IndexFileNames.SEGMENTS)) {      return 0;    } else if (fileName.startsWith(IndexFileNames.SEGMENTS)) {      return Long.parseLong(fileName.substring(1+IndexFileNames.SEGMENTS.length()),                            Character.MAX_RADIX);    } else {      throw new IllegalArgumentException("fileName \"" + fileName + "\" is not a segments file");    }  }  /**   * Get the next segments_N filename that will be written.   */  public String getNextSegmentFileName() {    long nextGeneration;    if (generation == -1) {      nextGeneration = 1;    } else {      nextGeneration = generation+1;    }    return IndexFileNames.fileNameFromGeneration(IndexFileNames.SEGMENTS,                                                 "",                                                 nextGeneration);  }  /**   * Read a particular segmentFileName.  Note that this may   * throw an IOException if a commit is in process.   *   * @param directory -- directory containing the segments file   * @param segmentFileName -- segment file to load   * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public final void read(Directory directory, String segmentFileName) throws CorruptIndexException, IOException {    boolean success = false;    // Clear any previous segments:    clear();    ChecksumIndexInput input = new ChecksumIndexInput(directory.openInput(segmentFileName));    generation = generationFromSegmentsFileName(segmentFileName);    lastGeneration = generation;    try {      int format = input.readInt();      if(format < 0){     // file contains explicit format info        // check that it is a format we can understand        if (format < CURRENT_FORMAT)          throw new CorruptIndexException("Unknown format version: " + format);        version = input.readLong(); // read version        counter = input.readInt(); // read counter      }      else{     // file is in old format without explicit format info        counter = format;      }            for (int i = input.readInt(); i > 0; i--) { // read segmentInfos        add(new SegmentInfo(directory, format, input));      }            if(format >= 0){    // in old format the version number may be at the end of the file        if (input.getFilePointer() >= input.length())          version = System.currentTimeMillis(); // old file format without version number        else          version = input.readLong(); // read version      }      if (format <= FORMAT_CHECKSUM) {        final long checksumNow = input.getChecksum();        final long checksumThen = input.readLong();        if (checksumNow != checksumThen)          throw new CorruptIndexException("checksum mismatch in segments file");      }      success = true;    }    finally {      input.close();      if (!success) {        // Clear any segment infos we had loaded so we        // have a clean slate on retry:        clear();      }    }  }  /**   * This version of read uses the retry logic (for lock-less   * commits) to find the right segments file to load.   * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public final void read(Directory directory) throws CorruptIndexException, IOException {    generation = lastGeneration = -1;    new FindSegmentsFile(directory) {      protected Object doBody(String segmentFileName) throws CorruptIndexException, IOException {        read(directory, segmentFileName);        return null;      }    }.run();  }  // Only non-null after prepareCommit has been called and  // before finishCommit is called  ChecksumIndexOutput pendingOutput;  private final void write(Directory directory) throws IOException {    String segmentFileName = getNextSegmentFileName();    // Always advance the generation on write:    if (generation == -1) {      generation = 1;    } else {      generation++;    }    ChecksumIndexOutput output = new ChecksumIndexOutput(directory.createOutput(segmentFileName));    boolean success = false;    try {      output.writeInt(CURRENT_FORMAT); // write FORMAT      output.writeLong(++version); // every write changes                                   // the index      output.writeInt(counter); // write counter      output.writeInt(size()); // write infos      for (int i = 0; i < size(); i++) {        info(i).write(output);      }      output.prepareCommit();      success = true;      pendingOutput = output;    } finally {      if (!success) {        // We hit an exception above; try to close the file        // but suppress any exception:        try {          output.close();        } catch (Throwable t) {          // Suppress so we keep throwing the original exception        }        try {          // Try not to leave a truncated segments_N file in          // the index:          directory.deleteFile(segmentFileName);        } catch (Throwable t) {          // Suppress so we keep throwing the original exception        }      }    }  }  /**   * Returns a copy of this instance, also copying each   * SegmentInfo.   */    public Object clone() {    SegmentInfos sis = (SegmentInfos) super.clone();    for(int i=0;i<sis.size();i++) {      sis.set(i, sis.info(i).clone());    }    return sis;  }  /**   * version number when this SegmentInfos was generated.   */  public long getVersion() {    return version;  }  public long getGeneration() {    return generation;  }  public long getLastGeneration() {    return lastGeneration;  }  /**   * Current version number from segments file.   * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public static long readCurrentVersion(Directory directory)    throws CorruptIndexException, IOException {    return ((Long) new FindSegmentsFile(directory) {        protected Object doBody(String segmentFileName) throws CorruptIndexException, IOException {          IndexInput input = directory.openInput(segmentFileName);          int format = 0;          long version = 0;          try {            format = input.readInt();            if(format < 0){              if (format < CURRENT_FORMAT)                throw new CorruptIndexException("Unknown format version: " + format);              version = input.readLong(); // read version            }          }          finally {            input.close();          }               if(format < 0)            return new Long(version);          // We cannot be sure about the format of the file.          // Therefore we have to read the whole file and cannot simply seek to the version entry.          SegmentInfos sis = new SegmentInfos();          sis.read(directory, segmentFileName);          return new Long(sis.getVersion());        }      }.run()).longValue();  }  /** If non-null, information about retries when loading   * the segments file will be printed to this.   */  public static void setInfoStream(PrintStream infoStream) {    SegmentInfos.infoStream = infoStream;  }  /* Advanced configuration of retry logic in loading     segments_N file */  private static int defaultGenFileRetryCount = 10;  private static int defaultGenFileRetryPauseMsec = 50;  private static int defaultGenLookaheadCount = 10;  /**   * Advanced: set how many times to try loading the   * segments.gen file contents to determine current segment   * generation.  This file is only referenced when the   * primary method (listing the directory) fails.   */  public static void setDefaultGenFileRetryCount(int count) {    defaultGenFileRetryCount = count;  }  /**   * @see #setDefaultGenFileRetryCount   */