← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/src/test/org/apache/lucene/index/TestStressIndexing.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/src/test/org/apache/lucene/index/TestStressIndexing.java
1
 
package org.apache.lucene.index;
2
 
 
3
 
/**
4
 
 * Copyright 2004 The Apache Software Foundation
5
 
 *
6
 
 * Licensed under the Apache License, Version 2.0 (the "License");
7
 
 * you may not use this file except in compliance with the License.
8
 
 * You may obtain a copy of the License at
9
 
 *
10
 
 *     http://www.apache.org/licenses/LICENSE-2.0
11
 
 *
12
 
 * Unless required by applicable law or agreed to in writing, software
13
 
 * distributed under the License is distributed on an "AS IS" BASIS,
14
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15
 
 * See the License for the specific language governing permissions and
16
 
 * limitations under the License.
17
 
 */
18
 
 
19
 
import org.apache.lucene.util.*;
20
 
import org.apache.lucene.store.*;
21
 
import org.apache.lucene.analysis.MockAnalyzer;
22
 
import org.apache.lucene.document.*;
23
 
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
24
 
import org.apache.lucene.search.*;
25
 
 
26
 
public class TestStressIndexing extends LuceneTestCase {
27
 
  private static abstract class TimedThread extends Thread {
28
 
    volatile boolean failed;
29
 
    int count;
30
 
    private static int RUN_TIME_MSEC = atLeast(1000);
31
 
    private TimedThread[] allThreads;
32
 
 
33
 
    abstract public void doWork() throws Throwable;
34
 
 
35
 
    TimedThread(TimedThread[] threads) {
36
 
      this.allThreads = threads;
37
 
    }
38
 
 
39
 
    @Override
40
 
    public void run() {
41
 
      final long stopTime = System.currentTimeMillis() + RUN_TIME_MSEC;
42
 
 
43
 
      count = 0;
44
 
 
45
 
      try {
46
 
        do {
47
 
          if (anyErrors()) break;
48
 
          doWork();
49
 
          count++;
50
 
        } while(System.currentTimeMillis() < stopTime);
51
 
      } catch (Throwable e) {
52
 
        System.out.println(Thread.currentThread() + ": exc");
53
 
        e.printStackTrace(System.out);
54
 
        failed = true;
55
 
      }
56
 
    }
57
 
 
58
 
    private boolean anyErrors() {
59
 
      for(int i=0;i<allThreads.length;i++)
60
 
        if (allThreads[i] != null && allThreads[i].failed)
61
 
          return true;
62
 
      return false;
63
 
    }
64
 
  }
65
 
 
66
 
  private class IndexerThread extends TimedThread {
67
 
    IndexWriter writer;
68
 
    int nextID;
69
 
 
70
 
    public IndexerThread(IndexWriter writer, TimedThread[] threads) {
71
 
      super(threads);
72
 
      this.writer = writer;
73
 
    }
74
 
 
75
 
    @Override
76
 
    public void doWork() throws Exception {
77
 
      // Add 10 docs:
78
 
      for(int j=0; j<10; j++) {
79
 
        Document d = new Document();
80
 
        int n = random.nextInt();
81
 
        d.add(newField("id", Integer.toString(nextID++), Field.Store.YES, Field.Index.NOT_ANALYZED));
82
 
        d.add(newField("contents", English.intToEnglish(n), Field.Store.NO, Field.Index.ANALYZED));
83
 
        writer.addDocument(d);
84
 
      }
85
 
 
86
 
      // Delete 5 docs:
87
 
      int deleteID = nextID-1;
88
 
      for(int j=0; j<5; j++) {
89
 
        writer.deleteDocuments(new Term("id", ""+deleteID));
90
 
        deleteID -= 2;
91
 
      }
92
 
    }
93
 
  }
94
 
 
95
 
  private static class SearcherThread extends TimedThread {
96
 
    private Directory directory;
97
 
 
98
 
    public SearcherThread(Directory directory, TimedThread[] threads) {
99
 
      super(threads);
100
 
      this.directory = directory;
101
 
    }
102
 
 
103
 
    @Override
104
 
    public void doWork() throws Throwable {
105
 
      for (int i=0; i<100; i++) {
106
 
        IndexReader ir = IndexReader.open(directory, true);
107
 
        IndexSearcher is = new IndexSearcher(ir);
108
 
        is.close();
109
 
        ir.close();
110
 
      }
111
 
      count += 100;
112
 
    }
113
 
  }
114
 
 
115
 
  /*
116
 
    Run one indexer and 2 searchers against single index as
117
 
    stress test.
118
 
  */
119
 
  public void runStressTest(Directory directory, MergeScheduler mergeScheduler) throws Exception {
120
 
    IndexWriter modifier = new IndexWriter(directory, newIndexWriterConfig(
121
 
        TEST_VERSION_CURRENT, new MockAnalyzer(random))
122
 
        .setOpenMode(OpenMode.CREATE).setMaxBufferedDocs(10).setMergeScheduler(
123
 
            mergeScheduler));
124
 
    modifier.commit();
125
 
    
126
 
    TimedThread[] threads = new TimedThread[4];
127
 
    int numThread = 0;
128
 
 
129
 
 
130
 
    // One modifier that writes 10 docs then removes 5, over
131
 
    // and over:
132
 
    IndexerThread indexerThread = new IndexerThread(modifier, threads);
133
 
    threads[numThread++] = indexerThread;
134
 
    indexerThread.start();
135
 
    
136
 
    IndexerThread indexerThread2 = new IndexerThread(modifier, threads);
137
 
    threads[numThread++] = indexerThread2;
138
 
    indexerThread2.start();
139
 
      
140
 
    // Two searchers that constantly just re-instantiate the
141
 
    // searcher:
142
 
    SearcherThread searcherThread1 = new SearcherThread(directory, threads);
143
 
    threads[numThread++] = searcherThread1;
144
 
    searcherThread1.start();
145
 
 
146
 
    SearcherThread searcherThread2 = new SearcherThread(directory, threads);
147
 
    threads[numThread++] = searcherThread2;
148
 
    searcherThread2.start();
149
 
 
150
 
    for(int i=0;i<numThread;i++)
151
 
      threads[i].join();
152
 
 
153
 
    modifier.close();
154
 
 
155
 
    for(int i=0;i<numThread;i++)
156
 
      assertTrue(! threads[i].failed);
157
 
 
158
 
    //System.out.println("    Writer: " + indexerThread.count + " iterations");
159
 
    //System.out.println("Searcher 1: " + searcherThread1.count + " searchers created");
160
 
    //System.out.println("Searcher 2: " + searcherThread2.count + " searchers created");
161
 
  }
162
 
 
163
 
  /*
164
 
    Run above stress test against RAMDirectory and then
165
 
    FSDirectory.
166
 
  */
167
 
  public void testStressIndexAndSearching() throws Exception {
168
 
    Directory directory = newDirectory();
169
 
    runStressTest(directory, new ConcurrentMergeScheduler());
170
 
    directory.close();
171
 
  }
172
 
}