From 72d4191588e4f60ea82a384f0406f3e464555107 Mon Sep 17 00:00:00 2001 From: Uwe Schindler Date: Tue, 20 Jul 2010 14:55:47 +0000 Subject: [PATCH] LUCENE-2523: Add IndexFormatTooOldException and IndexFormatTooNewException git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@965868 13f79535-47bb-0310-9956-ffa450edef68 --- .../appending/AppendingTermsDictReader.java | 3 +- .../appending/AppendingTermsIndexReader.java | 3 +- .../org/apache/lucene/index/CheckIndex.java | 14 ++-- .../org/apache/lucene/index/FieldInfos.java | 14 +++- .../org/apache/lucene/index/FieldsReader.java | 17 ++--- .../org/apache/lucene/index/FieldsWriter.java | 3 + .../index/IndexFormatTooNewException.java | 31 ++++++++ .../index/IndexFormatTooOldException.java | 32 ++++++++ .../org/apache/lucene/index/SegmentInfo.java | 5 +- .../org/apache/lucene/index/SegmentInfos.java | 25 +++---- .../lucene/index/TermVectorsReader.java | 26 ++++--- .../codecs/DefaultSegmentInfosReader.java | 10 ++- .../codecs/DefaultSegmentInfosWriter.java | 17 ++++- .../intblock/SimpleIntBlockIndexInput.java | 3 +- .../index/codecs/preflex/SegmentTermEnum.java | 12 ++- .../pulsing/PulsingPostingsReaderImpl.java | 3 +- .../codecs/sep/SepPostingsReaderImpl.java | 3 +- .../index/codecs/sep/SingleIntIndexInput.java | 3 +- .../SimpleStandardTermsIndexReader.java | 3 +- .../standard/StandardPostingsReaderImpl.java | 3 +- .../standard/StandardTermsDictReader.java | 3 +- .../org/apache/lucene/util/CodecUtil.java | 9 ++- .../apache/lucene/util/packed/PackedInts.java | 4 +- .../index/TestBackwardsCompatibility.java | 70 ++++++++++++++++++ .../lucene/index/unsupported.19.cfs.zip | Bin 0 -> 2747 bytes .../lucene/index/unsupported.19.nocfs.zip | Bin 0 -> 8528 bytes .../lucene/index/unsupported.20.cfs.zip | Bin 0 -> 2747 bytes .../lucene/index/unsupported.20.nocfs.zip | Bin 0 -> 8528 bytes .../lucene/index/unsupported.21.cfs.zip | Bin 0 -> 2784 bytes .../lucene/index/unsupported.21.nocfs.zip | Bin 0 -> 7705 bytes .../lucene/index/unsupported.22.cfs.zip | Bin 0 -> 1913 bytes .../lucene/index/unsupported.22.nocfs.zip | Bin 0 -> 5226 bytes .../lucene/index/unsupported.23.cfs.zip | Bin 0 -> 2091 bytes .../lucene/index/unsupported.23.nocfs.zip | Bin 0 -> 3375 bytes .../lucene/index/unsupported.24.cfs.zip | Bin 0 -> 3654 bytes .../lucene/index/unsupported.24.nocfs.zip | Bin 0 -> 7254 bytes .../lucene/index/unsupported.29.cfs.zip | Bin 0 -> 4531 bytes .../lucene/index/unsupported.29.nocfs.zip | Bin 0 -> 8733 bytes 38 files changed, 254 insertions(+), 62 deletions(-) create mode 100644 lucene/src/java/org/apache/lucene/index/IndexFormatTooNewException.java create mode 100644 lucene/src/java/org/apache/lucene/index/IndexFormatTooOldException.java create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.19.cfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.19.nocfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.20.cfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.20.nocfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.21.cfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.21.nocfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.22.cfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.22.nocfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.23.cfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.23.nocfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.24.cfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.24.nocfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.29.cfs.zip create mode 100644 lucene/src/test/org/apache/lucene/index/unsupported.29.nocfs.zip diff --git a/lucene/contrib/misc/src/java/org/apache/lucene/index/codecs/appending/AppendingTermsDictReader.java b/lucene/contrib/misc/src/java/org/apache/lucene/index/codecs/appending/AppendingTermsDictReader.java index 370ddc1d2c7..784eb8e34c8 100644 --- a/lucene/contrib/misc/src/java/org/apache/lucene/index/codecs/appending/AppendingTermsDictReader.java +++ b/lucene/contrib/misc/src/java/org/apache/lucene/index/codecs/appending/AppendingTermsDictReader.java @@ -42,7 +42,8 @@ public class AppendingTermsDictReader extends StandardTermsDictReader { @Override protected void readHeader(IndexInput in) throws IOException { - CodecUtil.checkHeader(in, AppendingTermsDictWriter.CODEC_NAME, StandardTermsDictWriter.VERSION_CURRENT); + CodecUtil.checkHeader(in, AppendingTermsDictWriter.CODEC_NAME, + StandardTermsDictWriter.VERSION_START, StandardTermsDictWriter.VERSION_CURRENT); } @Override diff --git a/lucene/contrib/misc/src/java/org/apache/lucene/index/codecs/appending/AppendingTermsIndexReader.java b/lucene/contrib/misc/src/java/org/apache/lucene/index/codecs/appending/AppendingTermsIndexReader.java index e61fe8c667e..3faa5d733bc 100644 --- a/lucene/contrib/misc/src/java/org/apache/lucene/index/codecs/appending/AppendingTermsIndexReader.java +++ b/lucene/contrib/misc/src/java/org/apache/lucene/index/codecs/appending/AppendingTermsIndexReader.java @@ -37,7 +37,8 @@ public class AppendingTermsIndexReader extends SimpleStandardTermsIndexReader { @Override protected void readHeader(IndexInput input) throws IOException { - CodecUtil.checkHeader(input, AppendingTermsIndexWriter.CODEC_NAME, AppendingTermsIndexWriter.VERSION_START); + CodecUtil.checkHeader(input, AppendingTermsIndexWriter.CODEC_NAME, + AppendingTermsIndexWriter.VERSION_START, AppendingTermsIndexWriter.VERSION_START); } @Override diff --git a/lucene/src/java/org/apache/lucene/index/CheckIndex.java b/lucene/src/java/org/apache/lucene/index/CheckIndex.java index 1dabe02c94f..7c17357a41c 100644 --- a/lucene/src/java/org/apache/lucene/index/CheckIndex.java +++ b/lucene/src/java/org/apache/lucene/index/CheckIndex.java @@ -24,6 +24,7 @@ import org.apache.lucene.store.IndexInput; import org.apache.lucene.document.AbstractField; // for javadocs import org.apache.lucene.document.Document; import org.apache.lucene.index.codecs.CodecProvider; +import org.apache.lucene.index.codecs.DefaultSegmentInfosWriter; import org.apache.lucene.util.Bits; import org.apache.lucene.util.BytesRef; @@ -343,12 +344,15 @@ public class CheckIndex { String sFormat = ""; boolean skip = false; - if (format == SegmentInfos.FORMAT_DIAGNOSTICS) + if (format == DefaultSegmentInfosWriter.FORMAT_DIAGNOSTICS) { sFormat = "FORMAT_DIAGNOSTICS [Lucene 2.9]"; - else if (format == SegmentInfos.FORMAT_4_0) - sFormat = "FORMAT_FLEX_POSTINGS [Lucene 4.0]"; - else if (format < SegmentInfos.CURRENT_FORMAT) { - sFormat = "int=" + format + " [newer version of Lucene than this tool]"; + } else if (format == DefaultSegmentInfosWriter.FORMAT_4_0) { + sFormat = "FORMAT_4_0 [Lucene 4.0]"; + } else if (format < DefaultSegmentInfosWriter.FORMAT_CURRENT) { + sFormat = "int=" + format + " [newer version of Lucene than this tool supports]"; + skip = true; + } else if (format > DefaultSegmentInfosWriter.FORMAT_MINIMUM) { + sFormat = "int=" + format + " [older version of Lucene than this tool supports]"; skip = true; } diff --git a/lucene/src/java/org/apache/lucene/index/FieldInfos.java b/lucene/src/java/org/apache/lucene/index/FieldInfos.java index bf065b2a81d..d4eb996e967 100644 --- a/lucene/src/java/org/apache/lucene/index/FieldInfos.java +++ b/lucene/src/java/org/apache/lucene/index/FieldInfos.java @@ -39,7 +39,10 @@ public final class FieldInfos { // First used in 2.9; prior to 2.9 there was no format header public static final int FORMAT_START = -2; - static final int CURRENT_FORMAT = FORMAT_START; + // whenever you add a new format, make it 1 smaller (negative version logic)! + static final int FORMAT_CURRENT = FORMAT_START; + + static final int FORMAT_MINIMUM = FORMAT_START; static final byte IS_INDEXED = 0x1; static final byte STORE_TERMVECTOR = 0x2; @@ -286,7 +289,7 @@ public final class FieldInfos { } public void write(IndexOutput output) throws IOException { - output.writeVInt(CURRENT_FORMAT); + output.writeVInt(FORMAT_CURRENT); output.writeVInt(size()); for (int i = 0; i < size(); i++) { FieldInfo fi = fieldInfo(i); @@ -307,8 +310,11 @@ public final class FieldInfos { private void read(IndexInput input, String fileName) throws IOException { format = input.readVInt(); - if (format > FORMAT_START) { - throw new CorruptIndexException("unrecognized format " + format + " in file \"" + fileName + "\""); + if (format > FORMAT_MINIMUM) { + throw new IndexFormatTooOldException(fileName, format, FORMAT_MINIMUM, FORMAT_CURRENT); + } + if (format < FORMAT_CURRENT) { + throw new IndexFormatTooNewException(fileName, format, FORMAT_MINIMUM, FORMAT_CURRENT); } final int size = input.readVInt(); //read in the size diff --git a/lucene/src/java/org/apache/lucene/index/FieldsReader.java b/lucene/src/java/org/apache/lucene/index/FieldsReader.java index 6211e335303..ee5882464ed 100644 --- a/lucene/src/java/org/apache/lucene/index/FieldsReader.java +++ b/lucene/src/java/org/apache/lucene/index/FieldsReader.java @@ -100,13 +100,15 @@ final class FieldsReader implements Cloneable { fieldInfos = fn; cloneableFieldsStream = d.openInput(IndexFileNames.segmentFileName(segment, "", IndexFileNames.FIELDS_EXTENSION), readBufferSize); - cloneableIndexStream = d.openInput(IndexFileNames.segmentFileName(segment, "", IndexFileNames.FIELDS_INDEX_EXTENSION), readBufferSize); + final String indexStreamFN = IndexFileNames.segmentFileName(segment, "", IndexFileNames.FIELDS_INDEX_EXTENSION); + cloneableIndexStream = d.openInput(indexStreamFN, readBufferSize); format = cloneableIndexStream.readInt(); + if (format < FieldsWriter.FORMAT_MINIMUM) + throw new IndexFormatTooOldException(indexStreamFN, format, FieldsWriter.FORMAT_MINIMUM, FieldsWriter.FORMAT_CURRENT); if (format > FieldsWriter.FORMAT_CURRENT) - throw new CorruptIndexException("Incompatible format version: " + format + " expected " - + FieldsWriter.FORMAT_CURRENT + " or lower"); + throw new IndexFormatTooNewException(indexStreamFN, format, FieldsWriter.FORMAT_MINIMUM, FieldsWriter.FORMAT_CURRENT); fieldsStream = (IndexInput) cloneableFieldsStream.clone(); @@ -185,11 +187,9 @@ final class FieldsReader implements Cloneable { } boolean canReadRawDocs() { - // Disable reading raw docs in 2.x format, because of the removal of compressed - // fields in 3.0. We don't want rawDocs() to decode field bits to figure out - // if a field was compressed, hence we enforce ordinary (non-raw) stored field merges - // for <3.0 indexes. - return format >= FieldsWriter.FORMAT_LUCENE_3_0_NO_COMPRESSED_FIELDS; + // Since we currently only support >3.0 format anymore, always return true! + // I leave this method in because it may help for later format changes. + return true; } final Document doc(int n, FieldSelector fieldSelector) throws CorruptIndexException, IOException { @@ -306,7 +306,6 @@ final class FieldsReader implements Cloneable { private void addField(Document doc, FieldInfo fi, boolean binary, boolean tokenize) throws CorruptIndexException, IOException { - //we have a binary stored field, and it may be compressed if (binary) { int toRead = fieldsStream.readVInt(); final byte[] b = new byte[toRead]; diff --git a/lucene/src/java/org/apache/lucene/index/FieldsWriter.java b/lucene/src/java/org/apache/lucene/index/FieldsWriter.java index dcc6c8df5b9..2b29270f73d 100644 --- a/lucene/src/java/org/apache/lucene/index/FieldsWriter.java +++ b/lucene/src/java/org/apache/lucene/index/FieldsWriter.java @@ -39,6 +39,9 @@ final class FieldsWriter // switch to a new format! static final int FORMAT_CURRENT = FORMAT_LUCENE_3_0_NO_COMPRESSED_FIELDS; + // when removing support for old versions, leave the last supported version here + static final int FORMAT_MINIMUM = FORMAT_LUCENE_3_0_NO_COMPRESSED_FIELDS; + private FieldInfos fieldInfos; private IndexOutput fieldsStream; diff --git a/lucene/src/java/org/apache/lucene/index/IndexFormatTooNewException.java b/lucene/src/java/org/apache/lucene/index/IndexFormatTooNewException.java new file mode 100644 index 00000000000..7448d88f758 --- /dev/null +++ b/lucene/src/java/org/apache/lucene/index/IndexFormatTooNewException.java @@ -0,0 +1,31 @@ +/** + * 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. + */ + +package org.apache.lucene.index; + +/** + * This exception is thrown when Lucene detects + * an index that is newer than this Lucene version. + */ +public class IndexFormatTooNewException extends CorruptIndexException { + + public IndexFormatTooNewException(String filename, int version, int minVersion, int maxVersion) { + super("Format version is not supported" + (filename!=null ? (" in file '" + filename + "'") : "") + + ": " + version + " (needs to be between " + minVersion + " and " + maxVersion + ")"); + } + +} diff --git a/lucene/src/java/org/apache/lucene/index/IndexFormatTooOldException.java b/lucene/src/java/org/apache/lucene/index/IndexFormatTooOldException.java new file mode 100644 index 00000000000..9be38a91e2a --- /dev/null +++ b/lucene/src/java/org/apache/lucene/index/IndexFormatTooOldException.java @@ -0,0 +1,32 @@ +/** + * 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. + */ + +package org.apache.lucene.index; + +/** + * This exception is thrown when Lucene detects + * an index that is too old for this Lucene version + */ +public class IndexFormatTooOldException extends CorruptIndexException { + + public IndexFormatTooOldException(String filename, int version, int minVersion, int maxVersion) { + super("Format version is not supported" + (filename!=null ? (" in file '" + filename + "'") : "") + + ": " + version + " (needs to be between " + minVersion + " and " + maxVersion + + "). This version of Lucene only supports indexes created with release 3.0 and later."); + } + +} diff --git a/lucene/src/java/org/apache/lucene/index/SegmentInfo.java b/lucene/src/java/org/apache/lucene/index/SegmentInfo.java index f5f46133022..46864813b51 100644 --- a/lucene/src/java/org/apache/lucene/index/SegmentInfo.java +++ b/lucene/src/java/org/apache/lucene/index/SegmentInfo.java @@ -22,6 +22,7 @@ import org.apache.lucene.store.IndexOutput; import org.apache.lucene.store.IndexInput; import org.apache.lucene.index.codecs.Codec; import org.apache.lucene.index.codecs.CodecProvider; +import org.apache.lucene.index.codecs.DefaultSegmentInfosWriter; import java.io.IOException; import java.util.Arrays; import java.util.List; @@ -154,7 +155,7 @@ public final class SegmentInfo { docStoreSegment = name; docStoreIsCompoundFile = false; } - if (format > SegmentInfos.FORMAT_4_0) { + if (format > DefaultSegmentInfosWriter.FORMAT_4_0) { // pre-4.0 indexes write a byte if there is a single norms file byte b = input.readByte(); assert 1 == b; @@ -177,7 +178,7 @@ public final class SegmentInfo { // System.out.println(Thread.currentThread().getName() + ": si.read hasProx=" + hasProx + " seg=" + name); - if (format <= SegmentInfos.FORMAT_4_0) + if (format <= DefaultSegmentInfosWriter.FORMAT_4_0) codecName = input.readString(); else codecName = "PreFlex"; diff --git a/lucene/src/java/org/apache/lucene/index/SegmentInfos.java b/lucene/src/java/org/apache/lucene/index/SegmentInfos.java index efcba816a4e..ecd4631c817 100644 --- a/lucene/src/java/org/apache/lucene/index/SegmentInfos.java +++ b/lucene/src/java/org/apache/lucene/index/SegmentInfos.java @@ -53,20 +53,10 @@ public final class SegmentInfos extends Vector { * be removed, however the numbers should continue to decrease. */ - /** Used for the segments.gen file only! */ + /** Used for the segments.gen file only! + * Whenever you add a new format, make it 1 smaller (negative version logic)! */ public static final int FORMAT_SEGMENTS_GEN_CURRENT = -2; - - /** This format adds optional per-segment String - * diagnostics storage, and switches userData to Map */ - public static final int FORMAT_DIAGNOSTICS = -9; - - /** Each segment records whether its postings are written - * in the new flex format */ - public static final int FORMAT_4_0 = -10; - - /* This must always point to the most recent file format. */ - public static final int CURRENT_FORMAT = FORMAT_4_0; - + public int counter = 0; // used to name new segments /** @@ -556,9 +546,16 @@ public final class SegmentInfos extends Vector { genB = gen0; break; } + } else { + /* TODO: Investigate this! + throw new IndexFormatTooNewException("segments.gen version number invalid: " + version + + " (must be " + FORMAT_SEGMENTS_GEN_CURRENT + ")"); + */ } } catch (IOException err2) { - // will retry + // rethrow any format exception + if (err2 instanceof CorruptIndexException) throw err2; + // else will retry } finally { genInput.close(); } diff --git a/lucene/src/java/org/apache/lucene/index/TermVectorsReader.java b/lucene/src/java/org/apache/lucene/index/TermVectorsReader.java index c0c18d95e71..63201238e53 100644 --- a/lucene/src/java/org/apache/lucene/index/TermVectorsReader.java +++ b/lucene/src/java/org/apache/lucene/index/TermVectorsReader.java @@ -35,7 +35,11 @@ class TermVectorsReader implements Cloneable { static final int FORMAT_UTF8_LENGTH_IN_BYTES = 4; // NOTE: always change this if you switch to a new format! + // whenever you add a new format, make it 1 larger (positive version logic)! static final int FORMAT_CURRENT = FORMAT_UTF8_LENGTH_IN_BYTES; + + // when removing support for old versions, leave the last supported version here + static final int FORMAT_MINIMUM = FORMAT_UTF8_LENGTH_IN_BYTES; //The size in bytes that the FORMAT_VERSION will take up at the beginning of each file static final int FORMAT_SIZE = 4; @@ -75,11 +79,13 @@ class TermVectorsReader implements Cloneable { String idxName = IndexFileNames.segmentFileName(segment, "", IndexFileNames.VECTORS_INDEX_EXTENSION); if (d.fileExists(idxName)) { tvx = d.openInput(idxName, readBufferSize); - format = checkValidFormat(tvx); - tvd = d.openInput(IndexFileNames.segmentFileName(segment, "", IndexFileNames.VECTORS_DOCUMENTS_EXTENSION), readBufferSize); - final int tvdFormat = checkValidFormat(tvd); - tvf = d.openInput(IndexFileNames.segmentFileName(segment, "", IndexFileNames.VECTORS_FIELDS_EXTENSION), readBufferSize); - final int tvfFormat = checkValidFormat(tvf); + format = checkValidFormat(tvx, idxName); + String fn = IndexFileNames.segmentFileName(segment, "", IndexFileNames.VECTORS_DOCUMENTS_EXTENSION); + tvd = d.openInput(fn, readBufferSize); + final int tvdFormat = checkValidFormat(tvd, fn); + fn = IndexFileNames.segmentFileName(segment, "", IndexFileNames.VECTORS_FIELDS_EXTENSION); + tvf = d.openInput(fn, readBufferSize); + final int tvfFormat = checkValidFormat(tvf, fn); assert format == tvdFormat; assert format == tvfFormat; @@ -183,13 +189,13 @@ class TermVectorsReader implements Cloneable { } } - private int checkValidFormat(IndexInput in) throws CorruptIndexException, IOException + private int checkValidFormat(IndexInput in, String fn) throws CorruptIndexException, IOException { int format = in.readInt(); - if (format > FORMAT_CURRENT) { - throw new CorruptIndexException("Incompatible format version: " + format + " expected " - + FORMAT_CURRENT + " or less"); - } + if (format < FORMAT_MINIMUM) + throw new IndexFormatTooOldException(fn, format, FORMAT_MINIMUM, FORMAT_CURRENT); + if (format > FORMAT_CURRENT) + throw new IndexFormatTooNewException(fn, format, FORMAT_MINIMUM, FORMAT_CURRENT); return format; } diff --git a/lucene/src/java/org/apache/lucene/index/codecs/DefaultSegmentInfosReader.java b/lucene/src/java/org/apache/lucene/index/codecs/DefaultSegmentInfosReader.java index bb13615d3da..099e58762dc 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/DefaultSegmentInfosReader.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/DefaultSegmentInfosReader.java @@ -20,6 +20,8 @@ package org.apache.lucene.index.codecs; import java.io.IOException; import org.apache.lucene.index.CorruptIndexException; +import org.apache.lucene.index.IndexFormatTooOldException; +import org.apache.lucene.index.IndexFormatTooNewException; import org.apache.lucene.index.SegmentInfo; import org.apache.lucene.index.SegmentInfos; import org.apache.lucene.store.ChecksumIndexInput; @@ -41,8 +43,12 @@ public class DefaultSegmentInfosReader extends SegmentInfosReader { int format = input.readInt(); // check that it is a format we can understand - if (format < SegmentInfos.CURRENT_FORMAT) - throw new CorruptIndexException("Unknown (newer than us?) format version: " + format); + if (format > DefaultSegmentInfosWriter.FORMAT_MINIMUM) + throw new IndexFormatTooOldException(segmentsFileName, format, + DefaultSegmentInfosWriter.FORMAT_MINIMUM, DefaultSegmentInfosWriter.FORMAT_CURRENT); + if (format < DefaultSegmentInfosWriter.FORMAT_CURRENT) + throw new IndexFormatTooNewException(segmentsFileName, format, + DefaultSegmentInfosWriter.FORMAT_MINIMUM, DefaultSegmentInfosWriter.FORMAT_CURRENT); infos.version = input.readLong(); // read version infos.counter = input.readInt(); // read counter diff --git a/lucene/src/java/org/apache/lucene/index/codecs/DefaultSegmentInfosWriter.java b/lucene/src/java/org/apache/lucene/index/codecs/DefaultSegmentInfosWriter.java index ee71c93aa75..9f5fb58419f 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/DefaultSegmentInfosWriter.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/DefaultSegmentInfosWriter.java @@ -31,11 +31,26 @@ import org.apache.lucene.store.IndexOutput; */ public class DefaultSegmentInfosWriter extends SegmentInfosWriter { + /** This format adds optional per-segment String + * diagnostics storage, and switches userData to Map */ + public static final int FORMAT_DIAGNOSTICS = -9; + + /** Each segment records whether its postings are written + * in the new flex format */ + public static final int FORMAT_4_0 = -10; + + /** This must always point to the most recent file format. + * whenever you add a new format, make it 1 smaller (negative version logic)! */ + public static final int FORMAT_CURRENT = FORMAT_4_0; + + /** This must always point to the first supported file format. */ + public static final int FORMAT_MINIMUM = FORMAT_DIAGNOSTICS; + @Override public IndexOutput writeInfos(Directory dir, String segmentFileName, SegmentInfos infos) throws IOException { IndexOutput out = createOutput(dir, segmentFileName); - out.writeInt(SegmentInfos.CURRENT_FORMAT); // write FORMAT + out.writeInt(FORMAT_CURRENT); // write FORMAT out.writeLong(++infos.version); // every write changes // the index out.writeInt(infos.counter); // write counter diff --git a/lucene/src/java/org/apache/lucene/index/codecs/intblock/SimpleIntBlockIndexInput.java b/lucene/src/java/org/apache/lucene/index/codecs/intblock/SimpleIntBlockIndexInput.java index cb137ab6af1..d03fc49fbae 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/intblock/SimpleIntBlockIndexInput.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/intblock/SimpleIntBlockIndexInput.java @@ -37,7 +37,8 @@ public class SimpleIntBlockIndexInput extends FixedIntBlockIndexInput { public SimpleIntBlockIndexInput(Directory dir, String fileName, int readBufferSize) throws IOException { IndexInput in = dir.openInput(fileName, readBufferSize); - CodecUtil.checkHeader(in, SimpleIntBlockIndexOutput.CODEC, SimpleIntBlockIndexOutput.VERSION_START); + CodecUtil.checkHeader(in, SimpleIntBlockIndexOutput.CODEC, + SimpleIntBlockIndexOutput.VERSION_START, SimpleIntBlockIndexOutput.VERSION_START); init(in); } diff --git a/lucene/src/java/org/apache/lucene/index/codecs/preflex/SegmentTermEnum.java b/lucene/src/java/org/apache/lucene/index/codecs/preflex/SegmentTermEnum.java index 85ba8849038..3c085aa0dda 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/preflex/SegmentTermEnum.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/preflex/SegmentTermEnum.java @@ -22,6 +22,8 @@ import org.apache.lucene.store.IndexInput; import org.apache.lucene.index.FieldInfos; import org.apache.lucene.index.Term; import org.apache.lucene.index.CorruptIndexException; +import org.apache.lucene.index.IndexFormatTooOldException; +import org.apache.lucene.index.IndexFormatTooNewException; /** * @deprecated No longer used with flex indexing, except for @@ -40,7 +42,11 @@ public final class SegmentTermEnum implements Cloneable { public static final int FORMAT_VERSION_UTF8_LENGTH_IN_BYTES = -4; // NOTE: always change this if you switch to a new format! + // whenever you add a new format, make it 1 smaller (negative version logic)! public static final int FORMAT_CURRENT = FORMAT_VERSION_UTF8_LENGTH_IN_BYTES; + + // when removing support for old versions, levae the last supported version here + public static final int FORMAT_MINIMUM = FORMAT_VERSION_UTF8_LENGTH_IN_BYTES; private TermBuffer termBuffer = new TermBuffer(); private TermBuffer prevBuffer = new TermBuffer(); @@ -78,8 +84,10 @@ public final class SegmentTermEnum implements Cloneable { format = firstInt; // check that it is a format we can understand - if (format < FORMAT_CURRENT) - throw new CorruptIndexException("Unknown format version:" + format + " expected " + FORMAT_CURRENT + " or higher"); + if (format > FORMAT_MINIMUM) + throw new IndexFormatTooOldException(null, format, FORMAT_MINIMUM, FORMAT_CURRENT); + if (format < FORMAT_CURRENT) + throw new IndexFormatTooNewException(null, format, FORMAT_MINIMUM, FORMAT_CURRENT); size = input.readLong(); // read the size diff --git a/lucene/src/java/org/apache/lucene/index/codecs/pulsing/PulsingPostingsReaderImpl.java b/lucene/src/java/org/apache/lucene/index/codecs/pulsing/PulsingPostingsReaderImpl.java index c3ac53bdf6e..8422b7bf37c 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/pulsing/PulsingPostingsReaderImpl.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/pulsing/PulsingPostingsReaderImpl.java @@ -51,7 +51,8 @@ public class PulsingPostingsReaderImpl extends StandardPostingsReader { @Override public void init(IndexInput termsIn) throws IOException { - CodecUtil.checkHeader(termsIn, PulsingPostingsWriterImpl.CODEC, PulsingPostingsWriterImpl.VERSION_START); + CodecUtil.checkHeader(termsIn, PulsingPostingsWriterImpl.CODEC, + PulsingPostingsWriterImpl.VERSION_START, PulsingPostingsWriterImpl.VERSION_START); maxPulsingDocFreq = termsIn.readVInt(); wrappedPostingsReader.init(termsIn); } diff --git a/lucene/src/java/org/apache/lucene/index/codecs/sep/SepPostingsReaderImpl.java b/lucene/src/java/org/apache/lucene/index/codecs/sep/SepPostingsReaderImpl.java index d70ffaf0ac4..8755362bcde 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/sep/SepPostingsReaderImpl.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/sep/SepPostingsReaderImpl.java @@ -95,7 +95,8 @@ public class SepPostingsReaderImpl extends StandardPostingsReader { @Override public void init(IndexInput termsIn) throws IOException { // Make sure we are talking to the matching past writer - CodecUtil.checkHeader(termsIn, SepPostingsWriterImpl.CODEC, SepPostingsWriterImpl.VERSION_START); + CodecUtil.checkHeader(termsIn, SepPostingsWriterImpl.CODEC, + SepPostingsWriterImpl.VERSION_START, SepPostingsWriterImpl.VERSION_START); skipInterval = termsIn.readInt(); maxSkipLevels = termsIn.readInt(); } diff --git a/lucene/src/java/org/apache/lucene/index/codecs/sep/SingleIntIndexInput.java b/lucene/src/java/org/apache/lucene/index/codecs/sep/SingleIntIndexInput.java index 482036b8876..4a639e3334a 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/sep/SingleIntIndexInput.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/sep/SingleIntIndexInput.java @@ -36,7 +36,8 @@ public class SingleIntIndexInput extends IntIndexInput { public SingleIntIndexInput(Directory dir, String fileName, int readBufferSize) throws IOException { in = dir.openInput(fileName, readBufferSize); - CodecUtil.checkHeader(in, SingleIntIndexOutput.CODEC, SingleIntIndexOutput.VERSION_START); + CodecUtil.checkHeader(in, SingleIntIndexOutput.CODEC, + SingleIntIndexOutput.VERSION_START, SingleIntIndexOutput.VERSION_START); } @Override diff --git a/lucene/src/java/org/apache/lucene/index/codecs/standard/SimpleStandardTermsIndexReader.java b/lucene/src/java/org/apache/lucene/index/codecs/standard/SimpleStandardTermsIndexReader.java index 86426bb1513..e409e4c2bb5 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/standard/SimpleStandardTermsIndexReader.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/standard/SimpleStandardTermsIndexReader.java @@ -146,7 +146,8 @@ public class SimpleStandardTermsIndexReader extends StandardTermsIndexReader { } protected void readHeader(IndexInput input) throws IOException { - CodecUtil.checkHeader(input, SimpleStandardTermsIndexWriter.CODEC_NAME, SimpleStandardTermsIndexWriter.VERSION_START); + CodecUtil.checkHeader(input, SimpleStandardTermsIndexWriter.CODEC_NAME, + SimpleStandardTermsIndexWriter.VERSION_START, SimpleStandardTermsIndexWriter.VERSION_START); dirOffset = input.readLong(); } diff --git a/lucene/src/java/org/apache/lucene/index/codecs/standard/StandardPostingsReaderImpl.java b/lucene/src/java/org/apache/lucene/index/codecs/standard/StandardPostingsReaderImpl.java index 4fb72eb6b54..2c53dc3bad2 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/standard/StandardPostingsReaderImpl.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/standard/StandardPostingsReaderImpl.java @@ -73,7 +73,8 @@ public class StandardPostingsReaderImpl extends StandardPostingsReader { public void init(IndexInput termsIn) throws IOException { // Make sure we are talking to the matching past writer - CodecUtil.checkHeader(termsIn, StandardPostingsWriterImpl.CODEC, StandardPostingsWriterImpl.VERSION_START); + CodecUtil.checkHeader(termsIn, StandardPostingsWriterImpl.CODEC, + StandardPostingsWriterImpl.VERSION_START, StandardPostingsWriterImpl.VERSION_START); skipInterval = termsIn.readInt(); maxSkipLevels = termsIn.readInt(); diff --git a/lucene/src/java/org/apache/lucene/index/codecs/standard/StandardTermsDictReader.java b/lucene/src/java/org/apache/lucene/index/codecs/standard/StandardTermsDictReader.java index 3f6114ed0ea..2abbe55985f 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/standard/StandardTermsDictReader.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/standard/StandardTermsDictReader.java @@ -153,7 +153,8 @@ public class StandardTermsDictReader extends FieldsProducer { } protected void readHeader(IndexInput input) throws IOException { - CodecUtil.checkHeader(in, StandardTermsDictWriter.CODEC_NAME, StandardTermsDictWriter.VERSION_CURRENT); + CodecUtil.checkHeader(in, StandardTermsDictWriter.CODEC_NAME, + StandardTermsDictWriter.VERSION_START, StandardTermsDictWriter.VERSION_CURRENT); dirOffset = in.readLong(); } diff --git a/lucene/src/java/org/apache/lucene/util/CodecUtil.java b/lucene/src/java/org/apache/lucene/util/CodecUtil.java index 3c5e3e63534..5e4c1d87b88 100644 --- a/lucene/src/java/org/apache/lucene/util/CodecUtil.java +++ b/lucene/src/java/org/apache/lucene/util/CodecUtil.java @@ -21,6 +21,8 @@ package org.apache.lucene.util; import org.apache.lucene.store.IndexOutput; import org.apache.lucene.store.IndexInput; import org.apache.lucene.index.CorruptIndexException; +import org.apache.lucene.index.IndexFormatTooNewException; +import org.apache.lucene.index.IndexFormatTooOldException; import java.io.IOException; @@ -48,7 +50,7 @@ public final class CodecUtil { return 9+codec.length(); } - public static int checkHeader(IndexInput in, String codec, int maxVersion) + public static int checkHeader(IndexInput in, String codec, int minVersion, int maxVersion) throws IOException { // Safety to guard against reading a bogus string: @@ -63,8 +65,11 @@ public final class CodecUtil { } final int actualVersion = in.readInt(); + if (actualVersion < minVersion) { + throw new IndexFormatTooOldException(null, actualVersion, minVersion, maxVersion); + } if (actualVersion > maxVersion) { - throw new CorruptIndexException("version " + actualVersion + " is too new (expected <= version " + maxVersion + ")"); + throw new IndexFormatTooNewException(null, actualVersion, minVersion, maxVersion); } return actualVersion; diff --git a/lucene/src/java/org/apache/lucene/util/packed/PackedInts.java b/lucene/src/java/org/apache/lucene/util/packed/PackedInts.java index ac02e59a47c..5fa78c4fa9c 100644 --- a/lucene/src/java/org/apache/lucene/util/packed/PackedInts.java +++ b/lucene/src/java/org/apache/lucene/util/packed/PackedInts.java @@ -157,7 +157,7 @@ public class PackedInts { * @lucene.internal */ public static Reader getReader(IndexInput in) throws IOException { - CodecUtil.checkHeader(in, CODEC_NAME, VERSION_START); + CodecUtil.checkHeader(in, CODEC_NAME, VERSION_START, VERSION_START); final int bitsPerValue = in.readVInt(); assert bitsPerValue > 0 && bitsPerValue <= 64: "bitsPerValue=" + bitsPerValue; final int valueCount = in.readVInt(); @@ -188,7 +188,7 @@ public class PackedInts { * @lucene.internal */ public static ReaderIterator getReaderIterator(IndexInput in) throws IOException { - CodecUtil.checkHeader(in, CODEC_NAME, VERSION_START); + CodecUtil.checkHeader(in, CODEC_NAME, VERSION_START, VERSION_START); final int bitsPerValue = in.readVInt(); assert bitsPerValue > 0 && bitsPerValue <= 64: "bitsPerValue=" + bitsPerValue; final int valueCount = in.readVInt(); diff --git a/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java b/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java index 56982554520..63c4e42e74d 100644 --- a/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java +++ b/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java @@ -23,6 +23,8 @@ import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; import java.util.Arrays; import java.util.Enumeration; import java.util.List; @@ -127,6 +129,74 @@ public class TestBackwardsCompatibility extends LuceneTestCase { "31.nocfs", }; + final String[] unsupportedNames = {"19.cfs", + "19.nocfs", + "20.cfs", + "20.nocfs", + "21.cfs", + "21.nocfs", + "22.cfs", + "22.nocfs", + "23.cfs", + "23.nocfs", + "24.cfs", + "24.nocfs", + "29.cfs", + "29.nocfs", + }; + + /** This test checks that *only* IndexFormatTooOldExceptions are throws when you open and operate on too old indexes! */ + public void testUnsupportedOldIndexes() throws Exception { + for(int i=0;i3.0 stored field change + fail("IndexReader.open should not pass for "+unsupportedNames[i]); + } catch (IndexFormatTooOldException e) { + // pass + } finally { + if (reader != null) reader.close(); + reader = null; + } + + try { + writer = new IndexWriter(dir, new IndexWriterConfig( + TEST_VERSION_CURRENT, new MockAnalyzer()) + .setMergeScheduler(new SerialMergeScheduler()) // no threads! + ); + writer.optimize(); + reader = writer.getReader(); + reader.document(0); // to catch also 2.9->3.0 stored field change + fail("IndexWriter creation should not pass for "+unsupportedNames[i]); + } catch (IndexFormatTooOldException e) { + // pass + } finally { + if (reader != null) reader.close(); + reader = null; + if (writer != null) writer.close(); + writer = null; + } + + ByteArrayOutputStream bos = new ByteArrayOutputStream(1024); + CheckIndex checker = new CheckIndex(dir); + checker.setInfoStream(new PrintStream(bos)); + CheckIndex.Status indexStatus = checker.checkIndex(); + assertFalse(indexStatus.clean); + assertTrue(bos.toString().contains(IndexFormatTooOldException.class.getName())); + + dir.close(); + rmDir(unsupportedNames[i]); + } + } + public void testOptimizeOldIndex() throws Exception { for(int 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 Qa+ffGfC0c|s3QRU1!b@v-2eap literal 0 HcmV?d00001 diff --git a/lucene/src/test/org/apache/lucene/index/unsupported.19.nocfs.zip b/lucene/src/test/org/apache/lucene/index/unsupported.19.nocfs.zip new file mode 100644 index 0000000000000000000000000000000000000000..e0d91424456b7e7d7735d5374e8d971579abe25f GIT binary patch literal 8528 zcmc(k4OCO-8OLuz2mxcD!jRMtfsVMC^c%(Q#hFaL9f~*`nDbtN|pr@|73TIZaTKB%WH{^Y9?!Cc4Ps6$A zz&Uw-_j%v@{QviPAGFKdL|z2^JQEW3bj!vY74G17c!`Oh5o?vI=TaN19?iUnP=>u_qV6PUtfXC!=%&zyO`%>x)uD2)^78W7PEo2csd8g*W!j9r zb$z9)KPOhHlJ&Ogm6`2qP|TkROE>heMq6e--oCWFpw#Gj%%g^Tp)rp<>att_x;0% z4;P6gq-a2_@F&T;-lF^JdIZZgjhN)}Xn*_|W%-B{LMelx=3wK6%&U-)*=f$=wpZ-h0ilTkD(p&ab^Z z^#0LzXS*wXU)-iDc0r7Wm zRSEH@DZTOwOEUQ4Y5~g2X64=NRLaZ>pQWEwUt4U5G@hQN4ADx;D~n$>p4mQnEoL_H z_RN~p5q0jR1#M?q_WZLp=CQe>og&fE>2hhpy)6cR)0LFN>8-<0&Bjx>ThUSl%QF&N z5?2+Fq|QwEhj+;i{ke92V3ohn`n>E0v$XxxtMD&)Sq&yLTAyWLT@U>&ftm5hcb^M% zhb{vV?ojEOTox4(^*XZv4=2{gFoW40>S%*yJi+V+#S(nC_BXvrAm#JmQPL~V=JBWb z&h079khD`5oa#4Y@4?VD!q8H0!# z7`@yH`PVmIyOzW34%jm^<*?fq?T0?JAFf!wTtBEI$!xNJU_eK{M7`={+$M|Obs zn){S_S^nE|{&;okVac*h*~#L4?HkUvNe)V@1LSgfz%E6VvQ%Z!*86-aeXe>*_!LQ& z=Rw9|mw%(Z`~*mBE|MIFnXMy%^7Uk<{uZhKI#aJdLA0$j&sktDmdy+P#7*(Cu8--&9X)1K;ZO=n*yY|=J>YxzK!0n-Fg@Z+{#e_cP@Tpf6-b0dM zL-PlH4Qon=OkqOtliqSsVRN4Tsopi4>u<*G%DHc}HXZgHVn5D18w7GlLzl=U3Z}Vj z>(Oa5yfhaV=Y)oTC}wP)gH0JGVpAa4b(;dgiD|Qy`efrc~qbDXfhO z`Mf@)Auc$%IX?MFR8p!jxp5<7#}yD_K^ zJ_V?g=TiVSsXk?ho@}2oL{G@4T1ENlb)YQXvFQZz*nKLh<3+FSv3{cdO-jY-x1PIF z^Ik^Do4z5n6?2aZT57JQy(5zbcD4n0$BusSz);o}ALbQeJ~C(4mC(DP>Ol7!gNuHs z>AHWW`PqySh^t$=^hvvkj?kziB7ram&{Tkk(IM@`(?Z>n!i2tc=3g*D2 ziHX@%(IePYbgot)1{E>Zih*D*n>uP?`oBXj2BOF9Q>((_A7DNOg86((<-DJos87KR zxSomYJ_V?g=TiVSsXkRS={{97F`wF8CLP3l3i6!#l(snH^^X=VdF8>v6}!#RM{04O z`U3dWPTHpiKI>k2Yo+KJ5x&4?v1@S+%Pr)3xG%*gJg2qBkre^+oX^;r~4lhq|>I0|7EK{b=ki~U&WW4_^ zhEFcQNsSU*5)faIwcePOYho`A*lL%E#fiiH)yg2LRQexv=Xt+(C3PqE4HPKS;&X|fKSj+z_T_0@K=`r zTWtVfu?_%xLyXVS&4u#B7jh^36WqgteXIBl81oyY90hiFxd#u5_t&t z6bvQ6j=z}~2eE5YDrh?-NBv?B%9s+t)#8*Mm1ZzjeL%@eyXbw$d1W>>Z1bac^ z^C*;{cB58dbsz_Vy&muh6iV1VMgS(mL%;_}D8Uzq8SbRjA{+?zRp3J-l#mGt^a#lT zU|$4&7NY>54nRrPQ2;pO=84BU6*T@!I-X6H_WN_k&j!ONIKbi;B|bYs@4tqQccMvr z_Ji)=RU2UZk`!Z-RDlK%uE2>R@zD;NK?x0TB1n9eg95rKz@z99UqXb%;+)P=L_};MXEP?mz*eGuoInWt2IlWXN%(XE-N8~DfPV+kmm6M&eKf#jC526)mf*6I ziYS2VO6s5h&Xj~t6VOeRORY<=_Ut@D;8s#I4RBdWejpuC2iDe^Cj)LJ?Xv;+>wsHH zBM<;iYWzyV&)(D?Qk5J7{woRNT~(5ij^|eregH@Be}s;ASxJ%J)B+x%O~jS7jRv@^ zq;4AEvXTOQtV?iRNqH2&nUe7HF7*_sX8W8C;OaZ+*WlmCpp2X~h}`d_(>8#s?Xo&8?egHrYiac`0kB2Cu4>0V9MGWB%XJ5nu@bdsfEcAtc{U7wo;b;H= literal 0 HcmV?d00001 diff --git a/lucene/src/test/org/apache/lucene/index/unsupported.20.cfs.zip b/lucene/src/test/org/apache/lucene/index/unsupported.20.cfs.zip new file mode 100644 index 0000000000000000000000000000000000000000..4b931ae2928acc271e6e9a84a3bf2737c858d295 GIT binary patch literal 2747 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 T;Q2`q8t@kbO7A3`?TP;bbU2R5 literal 0 HcmV?d00001 diff --git a/lucene/src/test/org/apache/lucene/index/unsupported.22.cfs.zip b/lucene/src/test/org/apache/lucene/index/unsupported.22.cfs.zip new file mode 100644 index 0000000000000000000000000000000000000000..1236307527d7f71cfed921d2c479470b9201107d GIT binary patch literal 1913 zcmWIWW@Zs#U|`^2c&w~$@$o&|#tSCKFF&QhA4ED_G;2uRr9i5Wc5mwBqoiO(l_4 zIYjOZLUr=&W&EGB!2RQo7Ja_ z46-5I+iuoq>Dxc!4FHA$7tr4f;81Wmy1N#{17QwuD8w7;rKILy4F{+?#s&tEA&8*N zES;Bl6)1TR7L_b-Xj_jE{yn-yz+$qW;Dmm99H|-kkhdsk*XKwZ~_sW>3!%>}h?C zGY%3P95dxKbXk_FF4!V7C9LsMRKP6;ui1u1Mh22n4W7;hnJj9(2bXZpFkzi6F!fo& zB_^M!fB*mg*S{j;rjW;w#HjF$iH$?xL-U-*B`wmfoW)5=N*=05%JlTy+!lOQNMKpm zqd0}L#i%tPP2iM_Q>252x4=X3C%^ZzaWkNWMuG5VqbtavVT3a@S|?a@9dZz8Gv<`) z?OK2A)TvWWCTeO2jWZrHPI|;cFd^}|qD{;84`G|$o$Fbk@Z<0wd3o!U!(t|< zH1}_)o~@F$chR!yYqKxKR;BEH{PNY>CKKi6jhA$~BAzc{zt(<9rMI+rr|+iHNsV%A z8G6bOoS1nuXlYb_*8j=r(`NFfb>B=Yn-QBf-;(J<$?ksJ1KT#X-{9NU?K@j;TfZ!a z;=Dhy6N)DWPfk9`K5^x$`#&NyYu8F7O04qTb$1iPldoE4i5>+UdWkL{IP4SyOy~L@ z`RN{qnl$wC0vOq#>4qJYzKnqBtJnZ*@>;!ebt4m6U{1`A{IVLTKOB~{jBy4gG-)Lx zCoT0RNYcsyC9P@+VA3j*Z`z?cbEbftGIvWf&(o?VY)Q)jlC&DQ;i*bOQgTKQ?|~(X zGfbE!A4|CO1ekW}7ivj1?qKX-ZJ5#B$f)sozI+P9Bq1{q)ia%)ojhwC)Na&-g#nWf zD=hhReBl1{H=dat&5t(Wi+F*lhyj$Lcz|J4oSL4SnpaY+m!6u3HK2Y2Ew^Xmc+hka z&7@1U?1i>KQ!0R%3(2JTM4aZtv$45-e30obW^7=vp}`<{595SKNev8c$NmEYK_s6; z=np@ufupjBqe469GG0BP5YLm%i(at+ZDwQ=XGRnPsO2dy&;<~%tr0}SN>^4$=^6@j zA;bV&MG>+AY{1BmH-HsP7)Bu6fLahC8{rKy0$MELF#t91A{!9N1T+AelkpgUn%*G> z0Ig=&)|kc&G60(T@tA;`;*p)O3}gZ{{o^qJH8~+0(8a=lmbma3gPN9*jk$tk3@Bxx V7{Ut5?ZB!8SeXDr%#Rhs0|0-yYw!R7 literal 0 HcmV?d00001 diff --git a/lucene/src/test/org/apache/lucene/index/unsupported.22.nocfs.zip b/lucene/src/test/org/apache/lucene/index/unsupported.22.nocfs.zip new file mode 100644 index 0000000000000000000000000000000000000000..216ddf305e08d57417c9dfb19b67a6ee4720ee37 GIT binary patch literal 5226 zcmb`Ldu&rx9LMkNyWPeZn>b)XaR@_0({^*ZO~YPxVHz!iO$mk;cDtGEjt=IVOr2tqYxHu$V1sG|_~NG4YWo%zsd{{?5I(^qjl)mfWt(N!M-n zbARWY&-vYNW_?<&$e<`nLtV>W@p$LHT?0$tlNpAJx{tCM4RwsWdcBsCZ@B5LK%=@@ zLEVruR4v2U^X!Uw9r__nd1k97eeP!6gI9{%3f}Ce(hgEqg1e+(^1nsEwBp?6=v;d- zea3nusdBo^nU=Fkd*XWUpxO7GXZ%x^sRIJV*1G!8AH#Ftdo;qey0%4S%G9;nU2ccV zP0O4NO_rAOYF23~AkZR&F^w-r#ndt#w56_Q$Fr_YyGk|-rdT!foJe7 zq+9>mT9vRI#3Jo|=i5~HAzsN#jjDuo64R3DcX0InWKHbq4~6u6w?DNdHJ-T32BdzJmRtKgTm;pe{$ zX7Alpo$|?sFJ2q-uFO^Xd-hO|J=}lzr>v>Gx6hB({{6KYEkR^Y%L5l$&?huBtbaC> zfpKh&dQblEXpdkeZWSI|qlaHU0fXI9lc>aIu(+$kKCXFYVe6W7qf@th)ZbTdXprg_ zT1>sDmk|~taI6g~rng#;s4J67oZ6gK>J!zygY$j)p7A=i*vO1$SPabBuoy72VzJ4P zsKq8jA{LtriCX+<%cAx|P@y5BgWDO);!9~BV{+NrB-d2w${##^SvwC5FZfD7`udYQ z-)Jv7zTjxrh^x*UJec0AW9~fCcfew3?Cx}%Ki^26WY^h!7CqeVu7PH81I>~RMBv#r z5SX)JAYf+2Ky$(dniDe6oUnm^h8#4JxX*yiH7zW!!bHx?T#}yW^e!l!l2YO29;H-PFHeRcQlI~g5NXOk>_)$9gghqH~ zF+`>1@S^2PwU#{JQ&ql74P1UVdgO{bDpw0uWJkkW*U+OLt08ui^w5HQhq}}kp#CuVJjJ| zY;x3ZgILyNsCT%cs)^3SYKSVWV}do%eefQG+G{fm9Y(U{$K=>lD$C8Q&Wd-9Mq|In zxb8E0|HKv#Wf>0X{TbUe^X{Z7jV0L`CHhY7$&}@q^-S{Q+2g;WoJGs-m&XdpDNq3S zI_E|2;mEAyB6BqqClEMeqh|z@`Qf02y}i3R*Y-dmcmp!6XleV-gw9@Ksy^|Dl03h-VTR&+rNwIDmAM zPI7>FCXsmzui$nVAZ`+wv~YkOR+`LRA~ujQ3&*^VVNmEIAWArJ6txV#Oi*q%ihR`n DoEWry literal 0 HcmV?d00001 diff --git a/lucene/src/test/org/apache/lucene/index/unsupported.23.cfs.zip b/lucene/src/test/org/apache/lucene/index/unsupported.23.cfs.zip new file mode 100644 index 0000000000000000000000000000000000000000..b5fdeef08647f72e2a6e01f628b03ec4452e3278 GIT binary patch literal 2091 zcmb7_3piA17{|{T#^e^lko!H+xYsi4+79KG%P5j2cPbMZHD=ugiCki3luN=$LlbtI zC|OaPOD4BQMQc}ymaw@bmo90LBskV1PJ))j|6Bhq+=l0niINb9*`AO5g_GKplbc+~7bDSIOp%e)~TE zR{I)12APTSDJ#V@>uVyy^8D<0n|4~5ZTm$u4_{YxweM>GJ>4mE0_mK>sb~%HX5j}# zRn;W<>+$nwCt(@BVjZul%@8n}Qs)LnjK+8JZjx-H=4Yuju(Mv|OgD_QW}P+A<$7f| zl->Tm^`u}iMykn27-uY(z)+TaUl11}+O*^Ze2#+a71i#%`>fqmRw;r?w$3>YVFR1TPjCa^>w9trNYux$lj1J!!7xhGW+bpnS7!R3ml;vMC3Q4kaSWdsvy>Zxcq`S>2d3 zqPc_P1-R@ozY3!r*36*WM;(sYF@yYA`THH1L9fBaf*B;9oi9OWX-&89r$5&BU|Mz@ zH`Fu%6SH8V7fg7Ai3(0)u6_T_0o1wPAFaEHliLnX%A&{WO9Japi_zxNi)RO%);hNz zob&`cE5J^1+8nNK_VNp(VF(^IrI%5kbQdzDPV&~AQtBk|MF>h7K~iy+mw8T&qnBZC zO}XCgRph&hOHhhg2b=W}~5p*m_fHA@@=D()zjR z+)Tw+Ev70&_4_SaCuQbUrlf{!TjKXD^tTWL=azoKW^kwLl{LWJ2Qe7M3azVfotfi=Xt6m!uUKBm-BvB^f zP+Qpe;>t|4!{5@$-eecK^P(a{W`ao6w7-U-q(~!*^fS`phm3IyB_W2W+#VCNJ3dKg zEW)M}Id64Et2ZsLC+WjxI?IaT6pWGnUriSy$Y5#CbPEiDl9Lxi$J>OTv7OCUWT`t* z2gb;wm2%W&H+9zOP1MKgr3c-#Ssv1*3;L=o?I>r@(VWp92zB6hEf#HuvnQRhFla$V znyRp@`zglrNtj)Ul!b7&@<+<9QSKR|GbPUT^)BUkb&=xk zhogqGsZO~S_7Zj?rl$rq)1}@a7Do{Xp&a`*kMx8fwX9Y~mEz!aXw3t1CMDaQKbjpN zeRW}hcc)pEp~;6TU4!rSj@CVo47J8T{V-v&58wRKe=^a~t7KMzW<5p^?Iqp}RbspN zgfI7nJb8%kue}p|2+>8n-nTVe4U1{J<4;d+fT=WUtB)<4?2Ws8Z&J!FH)Ezg7eSQtpMoNpAB7@}ULa5Slyd#Xpzb6ncKrnuTx4hjw zDyfNzrAXPFjeHg&s}H2g#PUl*eIZ8Xa*lx5eMZJ&`0x>29fySY#XuNXjRFE!rh zLhN9?JY6Y{JzU}V8yT2M=T=zOwC~B8lO+&irU}*$tJ70&_m-rUEI}PX590$p3|R3n z{{l*vAb8IS_=<;Nb&y%jRG&K+pW5#sIKKL*E>D6{7$o(-rxJp^}iba*IIg_YXi7+JSf) z7@Ts6K_N(=VBZx!4fOr$b>6Sp=GtlR(%GS5@4&QWX(MeC^=3s=vh?+P^jyN6&owrw zQh!xlm`DG)kj#_ZDn-?iy%eEA6&H5yXmQgvqPbOWr^oUqQE}JeB)~!;TnOmev~S#k zI3lhdw@94!DNEkigM-bxL_)oY{tf L=LN8E(#q36{%0j8 literal 0 HcmV?d00001 diff --git a/lucene/src/test/org/apache/lucene/index/unsupported.23.nocfs.zip b/lucene/src/test/org/apache/lucene/index/unsupported.23.nocfs.zip new file mode 100644 index 0000000000000000000000000000000000000000..9137ae6f32360089050f83700428fec410935f54 GIT binary patch literal 3375 zcmai$4ItC`AIE>pW<$4m7Kw;!m6;?xh&FMVWO*oZd7Pm{42cwZh`Osg^bcJzDfw4_ z%0H`H$co}48p1Nn*-)998>%PRdO?>+OSeW2J#YJrAXM-D=-2K&|1a=tZJmpWDNcM>=`9I7j)~i#wQCeCM3q` z6?DsA9hZ5NaEC82r;3&7-s+bc3{WO58Idx@N-R@=?-rSsWonm}W?L&TbNvfG1fiQc zkxWlD=7(?4O>eN5^GU%K8_`V!)a5o(@Hdt#60l^(zevFZ>lKwsWJU*Ra6c~ZTP%6> z7HRM>E|053$xr4@g-|E;QZ#Z$U>=PQ=^{kr9$-pc$h-eVRbZ$!VQPB%|oYE4Ns0*eiofX7={@U7@;t@3Lo?_fAju z3+}F7yL));t)0K;b@98KpPkJ*f6j**yCQb}ckaqe4O?mP;@_J?(=+`^x=+($|3e38=K` zE%&iB3N#P-Yt?mPKfuYz{?mb|5QaqLjb^hj4p9x&JMLfXw!O1P6`^8c#8V_jU{rr7 zb6bLOiEc6(a0~2(bO)Yzwln0^ewj+4q%&O{kl=p(l?u$~3! zYPXAr?W#;a`rIs;s=t77+l`OomHV?ys#x!qEV4fOY8!dKle^0D&8quqGaP?(yqvek zE;58~&$mRdNk3gH8mz~jCn!HiwFn=@9Vp&?<@8j}or~QM`DxWy++A+xm{ml=WbgZN zB~&j`i6m$5tK@wRYcc#KsJ-{hgR6dM1EOre!Q8`-Q~aygt0KUo%l*O=@%6t%rJtGw zYU4MzSEFKR5^G~oN0R6GLWzB)Z_j5h$D89FT#U0aJ){3T5q)X^*KAVwKjCLO%7 z-OAF^H2^Oe;~O@U(RM3cTmy^4KQqphWi?c2GcJXy1Prfd8@F56^YQDP%l*#8Q95g%-Kaf%;8jQHU|Gbu%DCzT z8Sz~9B*%Qm1G)6*&Gk8kE-{z4Tr&mE795f{!Oqe$^bhRUy_a#$BTHQ~3ZZ>-Oyg#z z+S2>vc&>l`CaoGB4@^EDmBwwfQa0O%R;`Pl6JN})Yv)%3t)7!TA zdA{?mn(zkeoOFBESedKcuG+gDn#=D0kk+%_<#V4G8Do@9{eMrNodZq`>Qe7An-qX?_h@aT^?RCCPP8@&wE z%-{6d`p$>uA2;Q9#g9C_6ka9ht9Rxeop@WTcdT+!v!m$Ay+eHsx4rU@Od#N(6hIiz zjCs;86g4jb@8N--F;5>e0xd99Vt>GIU;&Ux1W)sJ^UFK>@6q5Y{Js1vhe4ExxmHpm z`-U1jkMO{=t6dTN8#Z<&Kwtz09S97IVi1A?!z5y0p|Jr%lh!<+#7eL-0+hXAD2R}J z%opV7p-}dzELZI48fdY8qgpsrl)YF#@tqAW@!_+dkm;gwcoiHu47{$N+X3h|!GN=k z3pq##I3V1hY;fMF6ghLOYH;T{x$?MpryWg>PfZDwv^8TYr?Sk=Th_QTTu#<-j7n;a zCMWC$Co_;4^@~f0y19q(CF(dA?qd&AQ=1JpJW5xVCn~0g_+CG*0Wy`5)kG|G_<_49 zyj3K@ud_!Xr0^)@9t*ck93Xxy5Cwb-*69oYtWhZdajzByw0s4?&MgHXZpESi3t$a! z1h6qn0f^hF5CEozDw1vq0W;<*1t9LCq7h690W+Q|1t4yZq5v9VCWRTZlmZYpLs0;0 z767bK3P9X3L;)>w!U$mhkOB~wX;DBv@+$y{wiJN4yomy?qP_woEu@8{NEEPH9tO+` zlav_5RY-^su7uQC1guF?2;wRv8pI<&5Z5GW7%>SF#V7-noW;O`v;gFPRc0=mq9g`@ c{G&O50BeqLb0a~mAqWTVOF`cSup~o&1Ckg##sB~S literal 0 HcmV?d00001 diff --git a/lucene/src/test/org/apache/lucene/index/unsupported.24.cfs.zip b/lucene/src/test/org/apache/lucene/index/unsupported.24.cfs.zip new file mode 100644 index 0000000000000000000000000000000000000000..2c666a923f9ae8e88e107a205630b738372d13b6 GIT binary patch literal 3654 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 qKZV+8~7i=!Eu`a literal 0 HcmV?d00001 diff --git a/lucene/src/test/org/apache/lucene/index/unsupported.24.nocfs.zip b/lucene/src/test/org/apache/lucene/index/unsupported.24.nocfs.zip new file mode 100644 index 0000000000000000000000000000000000000000..c2238751427665f5977f8f5a986878438979815c GIT binary patch literal 7254 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 Irym6U9|26j9RL6T literal 0 HcmV?d00001 diff --git a/lucene/src/test/org/apache/lucene/index/unsupported.29.cfs.zip b/lucene/src/test/org/apache/lucene/index/unsupported.29.cfs.zip new file mode 100644 index 0000000000000000000000000000000000000000..c694c78181dfc80b9fe024985873997bb79093ed GIT binary patch literal 4531 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 OgFoY7(Gi6PUEqJMFEF