LUCENE-1143: clear docStoreOffset when DocumentsWriter aborts

git-svn-id: https://svn.apache.org/repos/asf/lucene/java/trunk@613606 13f79535-47bb-0310-9956-ffa450edef68

src/java/org/apache/lucene/index/DocumentsWriter.java

@@ -423,6 +423,8 @@ final class DocumentsWriter {
         resetPostingsData();
 
         docStoreSegment = null;
+        numDocsInStore = 0;
+        docStoreOffset = 0;
         files = null;
 
       } finally {

src/java/org/apache/lucene/index/IndexWriter.java

@@ -2447,6 +2447,11 @@ public class IndexWriter {
       }
 
       int docStoreOffset = docWriter.getDocStoreOffset();
+
+      // docStoreOffset should only be non-zero when
+      // autoCommit == false
+      assert !autoCommit || 0 == docStoreOffset;
+
       boolean docStoreIsCompoundFile = false;
 
       // Check if the doc stores must be separately flushed

src/test/org/apache/lucene/index/TestConcurrentMergeScheduler.java

@@ -76,10 +76,8 @@ public class TestConcurrentMergeScheduler extends LuceneTestCase {
         writer.addDocument(doc);
       }
 
-      // Even though this won't delete any docs,
+      writer.addDocument(doc);
-      // IndexWriter's flush will still make a clone for all
+
-      // SegmentInfos on hitting the exception:
-      writer.deleteDocuments(new Term("id", "1000"));
       failure.setDoFail();
       try {
         writer.flush();

src/test/org/apache/lucene/index/TestIndexWriter.java

@@ -2254,8 +2254,9 @@ public class TestIndexWriter extends LuceneTestCase
 
       int idUpto = 0;
       int fullCount = 0;
+      final long stopTime = System.currentTimeMillis() + 500;
 
-      while(true) {
+      while(System.currentTimeMillis() < stopTime) {
         try {
           writer.updateDocument(new Term("id", ""+(idUpto++)), doc);
         } catch (IOException ioe) {
@@ -2435,17 +2436,24 @@ public class TestIndexWriter extends LuceneTestCase
 
   // Throws IOException during FieldsWriter.flushDocument and during DocumentsWriter.abort
   private static class FailOnlyOnAbortOrFlush extends MockRAMDirectory.Failure {
+    private boolean onlyOnce;
+    public FailOnlyOnAbortOrFlush(boolean onlyOnce) {
+      this.onlyOnce = true;
+    }
     public void eval(MockRAMDirectory dir)  throws IOException {
       if (doFail) {
         StackTraceElement[] trace = new Exception().getStackTrace();
         for (int i = 0; i < trace.length; i++) {
           if ("abort".equals(trace[i].getMethodName()) ||
-              "flushDocument".equals(trace[i].getMethodName()))
+              "flushDocument".equals(trace[i].getMethodName())) {
+            if (onlyOnce)
+              doFail = false;
             throw new IOException("now failing on purpose");
           }
         }
       }
     }
+  }
 
   // Runs test, with one thread, using the specific failure
   // to trigger an IOException
@@ -2522,11 +2530,24 @@ public class TestIndexWriter extends LuceneTestCase
           assertTrue("hit unexpected Throwable", threads[i].error == null);
       }
 
+      boolean success = false;
       try {
         writer.close(false);
+        success = true;
       } catch (IOException ioe) {
       }
 
+      if (success) {
+        IndexReader reader = IndexReader.open(dir);
+        for(int j=0;j<reader.maxDoc();j++) {
+          if (!reader.isDeleted(j)) {
+            reader.document(j);
+            reader.getTermFreqVectors(j);
+          }
+        }
+        reader.close();
+      }
+
       dir.close();
     }
   }
@@ -2534,57 +2555,105 @@ public class TestIndexWriter extends LuceneTestCase
   // LUCENE-1130: make sure initial IOException, and then 2nd
   // IOException during abort(), is OK:
   public void testIOExceptionDuringAbort() throws IOException {
-    _testSingleThreadFailure(new FailOnlyOnAbortOrFlush());
+    _testSingleThreadFailure(new FailOnlyOnAbortOrFlush(false));
+  }
+
+  // LUCENE-1130: make sure initial IOException, and then 2nd
+  // IOException during abort(), is OK:
+  public void testIOExceptionDuringAbortOnlyOnce() throws IOException {
+    _testSingleThreadFailure(new FailOnlyOnAbortOrFlush(true));
   }
 
   // LUCENE-1130: make sure initial IOException, and then 2nd
   // IOException during abort(), with multiple threads, is OK:
   public void testIOExceptionDuringAbortWithThreads() throws IOException {
-    _testMultipleThreadsFailure(new FailOnlyOnAbortOrFlush());
+    _testMultipleThreadsFailure(new FailOnlyOnAbortOrFlush(false));
+  }
+
+  // LUCENE-1130: make sure initial IOException, and then 2nd
+  // IOException during abort(), with multiple threads, is OK:
+  public void testIOExceptionDuringAbortWithThreadsOnlyOnce() throws IOException {
+    _testMultipleThreadsFailure(new FailOnlyOnAbortOrFlush(true));
   }
 
   // Throws IOException during DocumentsWriter.closeDocStore
   private static class FailOnlyInCloseDocStore extends MockRAMDirectory.Failure {
+    private boolean onlyOnce;
+    public FailOnlyInCloseDocStore(boolean onlyOnce) {
+      this.onlyOnce = true;
+    }
     public void eval(MockRAMDirectory dir)  throws IOException {
       if (doFail) {
         StackTraceElement[] trace = new Exception().getStackTrace();
         for (int i = 0; i < trace.length; i++) {
-          if ("closeDocStore".equals(trace[i].getMethodName()))
+          if ("closeDocStore".equals(trace[i].getMethodName())) {
+            if (onlyOnce)
+              doFail = false;
             throw new IOException("now failing on purpose");
           }
         }
       }
     }
+  }
 
   // LUCENE-1130: test IOException in closeDocStore
   public void testIOExceptionDuringCloseDocStore() throws IOException {
-    _testSingleThreadFailure(new FailOnlyInCloseDocStore());
+    _testSingleThreadFailure(new FailOnlyInCloseDocStore(false));
+  }
+
+  // LUCENE-1130: test IOException in closeDocStore
+  public void testIOExceptionDuringCloseDocStoreOnlyOnce() throws IOException {
+    _testSingleThreadFailure(new FailOnlyInCloseDocStore(true));
   }
 
   // LUCENE-1130: test IOException in closeDocStore, with threads
   public void testIOExceptionDuringCloseDocStoreWithThreads() throws IOException {
-    _testMultipleThreadsFailure(new FailOnlyInCloseDocStore());
+    _testMultipleThreadsFailure(new FailOnlyInCloseDocStore(false));
+  }
+
+  // LUCENE-1130: test IOException in closeDocStore, with threads
+  public void testIOExceptionDuringCloseDocStoreWithThreadsOnlyOnce() throws IOException {
+    _testMultipleThreadsFailure(new FailOnlyInCloseDocStore(true));
   }
 
   // Throws IOException during DocumentsWriter.writeSegment
   private static class FailOnlyInWriteSegment extends MockRAMDirectory.Failure {
+    private boolean onlyOnce;
+    public FailOnlyInWriteSegment(boolean onlyOnce) {
+      this.onlyOnce = true;
+    }
     public void eval(MockRAMDirectory dir)  throws IOException {
       if (doFail) {
         StackTraceElement[] trace = new Exception().getStackTrace();
         for (int i = 0; i < trace.length; i++) {
-          if ("writeSegment".equals(trace[i].getMethodName()))
+          if ("writeSegment".equals(trace[i].getMethodName())) {
+            if (onlyOnce)
+              doFail = false;
+            // new RuntimeException().printStackTrace(System.out);
             throw new IOException("now failing on purpose");
           }
         }
       }
     }
+  }
+
   // LUCENE-1130: test IOException in writeSegment
   public void testIOExceptionDuringWriteSegment() throws IOException {
-    _testSingleThreadFailure(new FailOnlyInWriteSegment());
+    _testSingleThreadFailure(new FailOnlyInWriteSegment(false));
+  }
+
+  // LUCENE-1130: test IOException in writeSegment
+  public void testIOExceptionDuringWriteSegmentOnlyOnce() throws IOException {
+    _testSingleThreadFailure(new FailOnlyInWriteSegment(true));
   }
 
   // LUCENE-1130: test IOException in writeSegment, with threads
   public void testIOExceptionDuringWriteSegmentWithThreads() throws IOException {
-    _testMultipleThreadsFailure(new FailOnlyInWriteSegment());
+    _testMultipleThreadsFailure(new FailOnlyInWriteSegment(false));
+  }
+
+  // LUCENE-1130: test IOException in writeSegment, with threads
+  public void testIOExceptionDuringWriteSegmentWithThreadsOnlyOnce() throws IOException {
+    _testMultipleThreadsFailure(new FailOnlyInWriteSegment(true));
   }
 }