Example usage for org.apache.lucene.index IndexWriterConfig setOpenMode

List of usage examples for org.apache.lucene.index IndexWriterConfig setOpenMode

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.index.*
  5. IndexWriterConfig
  6. setOpenMode

Introduction

In this page you can find the example usage for org.apache.lucene.index IndexWriterConfig setOpenMode.

Prototype

public IndexWriterConfig setOpenMode(OpenMode openMode)

Source Link

Document

Specifies OpenMode of the index.

Usage

From source file:org.opengrok.indexer.index.IndexDatabase.java

License:Open Source License

/**
 * Optimize the index database//from   www.  j ava2 s  .c o  m
 * @throws IOException I/O exception
 */
public void optimize() throws IOException {
    synchronized (lock) {
        if (running) {
            LOGGER.warning("Optimize terminated... Someone else is updating / optimizing it!");
            return;
        }
        running = true;
    }

    IndexWriter wrt = null;
    IOException writerException = null;
    try {
        Statistics elapsed = new Statistics();
        String projectDetail = this.project != null ? " for project " + project.getName() : "";
        LOGGER.log(Level.INFO, "Optimizing the index{0}", projectDetail);
        Analyzer analyzer = new StandardAnalyzer();
        IndexWriterConfig conf = new IndexWriterConfig(analyzer);
        conf.setOpenMode(OpenMode.CREATE_OR_APPEND);

        wrt = new IndexWriter(indexDirectory, conf);
        wrt.forceMerge(1); // this is deprecated and not needed anymore
        elapsed.report(LOGGER, String.format("Done optimizing index%s", projectDetail));
        synchronized (lock) {
            if (dirtyFile.exists() && !dirtyFile.delete()) {
                LOGGER.log(Level.FINE, "Failed to remove \"dirty-file\": {0}", dirtyFile.getAbsolutePath());
            }
            dirty = false;
        }
    } catch (IOException e) {
        writerException = e;
        LOGGER.log(Level.SEVERE, "ERROR: optimizing index: {0}", e);
    } finally {
        if (wrt != null) {
            try {
                wrt.close();
            } catch (IOException e) {
                if (writerException == null) {
                    writerException = e;
                }
                LOGGER.log(Level.WARNING, "An error occurred while closing writer", e);
            }
        }
        synchronized (lock) {
            running = false;
        }
    }

    if (writerException != null) {
        throw writerException;
    }
}

From source file:org.openmailarchive.index.LuceneMailIndexer.java

License:Open Source License

public LuceneMailIndexer(String indexDir) {
    StandardAnalyzer analyzer = new StandardAnalyzer();
    Directory index;//ww  w .j  a v a 2s. co m
    try {
        index = new NIOFSDirectory(Paths.get(indexDir));
        IndexWriterConfig config = new IndexWriterConfig(analyzer);
        config.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);
        w = new IndexWriter(index, config);
    } catch (IOException e) {
        e.printStackTrace();
    }

    toWrite = new ArrayList<>();
}

From source file:org.openrdf.sail.lucene.LuceneIndex.java

License:BSD License

/**
 * Creates a new LuceneIndex./*from  w  w  w . j  a  va  2s .  co  m*/
 * 
 * @param directory
 *        The Directory in which an index can be found and/or in which index
 *        files are written.
 * @param analyzer
 *        The Analyzer that will be used for tokenizing strings to index and
 *        queries.
 * @throws IOException
 *         When the Directory could not be unlocked.
 */
public LuceneIndex(Directory directory, Analyzer analyzer) throws IOException {
    this.directory = directory;
    this.analyzer = analyzer;
    this.queryAnalyzer = new StandardAnalyzer(Version.LUCENE_35);

    // get rid of any locks that may have been left by previous (crashed)
    // sessions
    if (IndexWriter.isLocked(directory)) {
        logger.info("unlocking directory {}", directory);
        IndexWriter.unlock(directory);
    }

    // do some initialization for new indices
    if (!IndexReader.indexExists(directory)) {
        logger.info("creating new Lucene index in directory {}", directory);
        IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_35, analyzer);
        indexWriterConfig.setOpenMode(OpenMode.CREATE);
        IndexWriter writer = new IndexWriter(directory, indexWriterConfig);
        writer.close();
    }
}

From source file:org.openrdf.sail.lucene.LuceneIndex.java

License:BSD License

/**
 * //from ww  w . j a  v a  2 s  .co  m
 */
public synchronized void clear() throws IOException {
    // clear
    // the old IndexReaders/Searchers are not outdated
    invalidateReaders();
    if (indexWriter != null)
        indexWriter.close();

    // crate new writer
    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_35, analyzer);
    indexWriterConfig.setOpenMode(OpenMode.CREATE);
    indexWriter = new IndexWriter(directory, indexWriterConfig);
    indexWriter.close();
    indexWriter = null;

}

From source file:org.openrdf.sail.lucene3.LuceneIndex.java

License:BSD License

private void postInit() throws IOException {
    this.queryAnalyzer = new StandardAnalyzer(Version.LUCENE_35);

    // get rid of any locks that may have been left by previous (crashed)
    // sessions/*from   w  ww .  j  a va  2 s. c  o  m*/
    if (IndexWriter.isLocked(directory)) {
        logger.info("unlocking directory {}", directory);
        IndexWriter.unlock(directory);
    }

    // do some initialization for new indices
    if (!IndexReader.indexExists(directory)) {
        logger.info("creating new Lucene index in directory {}", directory);
        IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_35, analyzer);
        indexWriterConfig.setOpenMode(OpenMode.CREATE);
        IndexWriter writer = new IndexWriter(directory, indexWriterConfig);
        writer.close();
    }
}

From source file:org.openrdf.sail.lucene3.LuceneIndex.java

License:BSD License

/**
 * // www  . j a  va 2  s  .c  o m
 */
@Override
public synchronized void clear() throws IOException {
    // clear
    // the old IndexReaders/Searchers are not outdated
    invalidateReaders();
    if (indexWriter != null)
        indexWriter.close();

    // crate new writer
    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_35, analyzer);
    indexWriterConfig.setOpenMode(OpenMode.CREATE);
    indexWriter = new IndexWriter(directory, indexWriterConfig);
    indexWriter.close();
    indexWriter = null;

}

From source file:org.openrdf.sail.lucene4.LuceneIndex.java

License:BSD License

private void postInit() throws IOException {
    this.queryAnalyzer = new StandardAnalyzer();

    // do some initialization for new indices
    if (!DirectoryReader.indexExists(directory)) {
        logger.info("creating new Lucene index in directory {}", directory);
        IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_4_10_4, analyzer);
        indexWriterConfig.setOpenMode(OpenMode.CREATE);
        IndexWriter writer = new IndexWriter(directory, indexWriterConfig);
        writer.close();/*from  w  ww  . j  ava 2s.  c om*/
    }
}

From source file:org.openrdf.sail.lucene4.LuceneIndex.java

License:BSD License

/**
 * //from  w w w  .j av a  2s.c o  m
 */
@Override
public synchronized void clear() throws IOException {
    // clear
    // the old IndexReaders/Searchers are not outdated
    invalidateReaders();
    if (indexWriter != null)
        indexWriter.close();

    // crate new writer
    IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_4_10_4, analyzer);
    indexWriterConfig.setOpenMode(OpenMode.CREATE);
    indexWriter = new IndexWriter(directory, indexWriterConfig);
    indexWriter.close();
    indexWriter = null;

}

From source file:org.opensolaris.opengrok.index.IndexDatabase.java

License:Open Source License

/**
 * Update the content of this index database
 *
 * @throws IOException if an error occurs
 * @throws HistoryException if an error occurs when accessing the history
 *///from  w  w  w. j  a  va2s.  c o m
public void update() throws IOException, HistoryException {
    synchronized (lock) {
        if (running) {
            throw new IOException("Indexer already running!");
        }
        running = true;
        interrupted = false;
    }

    String ctgs = RuntimeEnvironment.getInstance().getCtags();
    if (ctgs != null) {
        ctags = new Ctags();
        ctags.setBinary(ctgs);
    }
    if (ctags == null) {
        log.severe("Unable to run ctags! searching definitions will not work!");
    }

    if (ctags != null) {
        String filename = RuntimeEnvironment.getInstance().getCTagsExtraOptionsFile();
        if (filename != null) {
            ctags.setCTagsExtraOptionsFile(filename);
        }
    }

    try {
        Analyzer analyzer = AnalyzerGuru.getAnalyzer();
        IndexWriterConfig iwc = new IndexWriterConfig(SearchEngine.LUCENE_VERSION, analyzer);
        iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);
        iwc.setRAMBufferSizeMB(RuntimeEnvironment.getInstance().getRamBufferSize());
        writer = new IndexWriter(indexDirectory, iwc);
        writer.commit(); // to make sure index exists on the disk            

        if (directories.isEmpty()) {
            if (project == null) {
                directories.add("");
            } else {
                directories.add(project.getPath());
            }
        }

        for (String dir : directories) {
            File sourceRoot;
            if ("".equals(dir)) {
                sourceRoot = RuntimeEnvironment.getInstance().getSourceRootFile();
            } else {
                sourceRoot = new File(RuntimeEnvironment.getInstance().getSourceRootFile(), dir);
            }

            HistoryGuru.getInstance().ensureHistoryCacheExists(sourceRoot);

            String startuid = Util.path2uid(dir, "");
            IndexReader reader = DirectoryReader.open(indexDirectory); // open existing index
            Terms terms = null;
            int numDocs = reader.numDocs();
            if (numDocs > 0) {
                Fields uFields = MultiFields.getFields(reader);//reader.getTermVectors(0);
                terms = uFields.terms(QueryBuilder.U);
            }

            try {
                if (numDocs > 0) {
                    uidIter = terms.iterator(uidIter);
                    TermsEnum.SeekStatus stat = uidIter.seekCeil(new BytesRef(startuid)); //init uid                        
                    if (stat == TermsEnum.SeekStatus.END) {
                        uidIter = null;
                        log.log(Level.WARNING, "Couldn't find a start term for {0}, empty u field?", startuid);
                    }
                }
                // The code below traverses the tree to get total count.
                int file_cnt = 0;
                if (RuntimeEnvironment.getInstance().isPrintProgress()) {
                    log.log(Level.INFO, "Counting files in {0} ...", dir);
                    file_cnt = indexDown(sourceRoot, dir, true, 0, 0);
                    if (log.isLoggable(Level.INFO)) {
                        log.log(Level.INFO, "Need to process: {0} files for {1}",
                                new Object[] { file_cnt, dir });
                    }
                }

                indexDown(sourceRoot, dir, false, 0, file_cnt);

                while (uidIter != null && uidIter.term() != null
                        && uidIter.term().utf8ToString().startsWith(startuid)) {

                    removeFile();
                    BytesRef next = uidIter.next();
                    if (next == null) {
                        uidIter = null;
                    }
                }
            } finally {
                reader.close();
            }
        }
    } finally {
        if (writer != null) {
            try {
                writer.prepareCommit();
                writer.commit();
                writer.close();
            } catch (IOException e) {
                log.log(Level.WARNING, "An error occured while closing writer", e);
            }
        }

        if (ctags != null) {
            try {
                ctags.close();
            } catch (IOException e) {
                log.log(Level.WARNING, "An error occured while closing ctags process", e);
            }
        }

        synchronized (lock) {
            running = false;
        }
    }

    if (!isInterrupted() && isDirty()) {
        if (RuntimeEnvironment.getInstance().isOptimizeDatabase()) {
            optimize();
        }
        RuntimeEnvironment env = RuntimeEnvironment.getInstance();
        File timestamp = new File(env.getDataRootFile(), "timestamp");
        String purpose = "used for timestamping the index database.";
        if (timestamp.exists()) {
            if (!timestamp.setLastModified(System.currentTimeMillis())) {
                log.log(Level.WARNING, "Failed to set last modified time on ''{0}'', {1}",
                        new Object[] { timestamp.getAbsolutePath(), purpose });
            }
        } else {
            if (!timestamp.createNewFile()) {
                log.log(Level.WARNING, "Failed to create file ''{0}'', {1}",
                        new Object[] { timestamp.getAbsolutePath(), purpose });
            }
        }
    }
}