testlockfactory.java

Lucene a java open-source SearchEngine Framework

package org.apache.lucene.store;

/**
 * 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.util.LuceneTestCase;

import java.util.Hashtable;
import java.util.Enumeration;

import java.io.IOException;
import java.io.File;

import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.Hits;
import org.apache.lucene.analysis.WhitespaceAnalyzer;

public class TestLockFactory extends LuceneTestCase {

    // Verify: we can provide our own LockFactory implementation, the right
    // methods are called at the right time, locks are created, etc.

    public void testCustomLockFactory() throws IOException {
        Directory dir = new RAMDirectory();
        MockLockFactory lf = new MockLockFactory();
        dir.setLockFactory(lf);

        // Lock prefix should have been set:
        assertTrue("lock prefix was not set by the RAMDirectory", lf.lockPrefixSet);

        IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);

        // add 100 documents (so that commit lock is used)
        for (int i = 0; i < 100; i++) {
            addDoc(writer);
        }

        // Both write lock and commit lock should have been created:
        assertEquals("# of unique locks created (after instantiating IndexWriter)",
                     1, lf.locksCreated.size());
        assertTrue("# calls to makeLock is 0 (after instantiating IndexWriter)",
                   lf.makeLockCount >= 1);
        
        for(Enumeration e = lf.locksCreated.keys(); e.hasMoreElements();) {
            String lockName = (String) e.nextElement();
            MockLockFactory.MockLock lock = (MockLockFactory.MockLock) lf.locksCreated.get(lockName);
            assertTrue("# calls to Lock.obtain is 0 (after instantiating IndexWriter)",
                       lock.lockAttempts > 0);
        }
        
        writer.close();
    }

    // Verify: we can use the NoLockFactory with RAMDirectory w/ no
    // exceptions raised:
    // Verify: NoLockFactory allows two IndexWriters
    public void testRAMDirectoryNoLocking() throws IOException {
        Directory dir = new RAMDirectory();
        dir.setLockFactory(NoLockFactory.getNoLockFactory());

        assertTrue("RAMDirectory.setLockFactory did not take",
                   NoLockFactory.class.isInstance(dir.getLockFactory()));

        IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);

        // Create a 2nd IndexWriter.  This is normally not allowed but it should run through since we're not
        // using any locks:
        IndexWriter writer2 = null;
        try {
            writer2 = new IndexWriter(dir, new WhitespaceAnalyzer(), false);
        } catch (Exception e) {
            e.printStackTrace(System.out);
            fail("Should not have hit an IOException with no locking");
        }

        writer.close();
        if (writer2 != null) {
            writer2.close();
        }
    }

    // Verify: SingleInstanceLockFactory is the default lock for RAMDirectory
    // Verify: RAMDirectory does basic locking correctly (can't create two IndexWriters)
    public void testDefaultRAMDirectory() throws IOException {
        Directory dir = new RAMDirectory();

        assertTrue("RAMDirectory did not use correct LockFactory: got " + dir.getLockFactory(),
                   SingleInstanceLockFactory.class.isInstance(dir.getLockFactory()));

        IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);

        // Create a 2nd IndexWriter.  This should fail:
        IndexWriter writer2 = null;
        try {
            writer2 = new IndexWriter(dir, new WhitespaceAnalyzer(), false);
            fail("Should have hit an IOException with two IndexWriters on default SingleInstanceLockFactory");
        } catch (IOException e) {
        }

        writer.close();
        if (writer2 != null) {
            writer2.close();
        }
    }

    // Verify: SimpleFSLockFactory is the default for FSDirectory
    // Verify: FSDirectory does basic locking correctly
    public void testDefaultFSDirectory() throws IOException {
        String indexDirName = "index.TestLockFactory1";

        IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);

        assertTrue("FSDirectory did not use correct LockFactory: got " + writer.getDirectory().getLockFactory(),
                   SimpleFSLockFactory.class.isInstance(writer.getDirectory().getLockFactory()) ||
                   NativeFSLockFactory.class.isInstance(writer.getDirectory().getLockFactory()));

        IndexWriter writer2 = null;

        // Create a 2nd IndexWriter.  This should fail:
        try {
            writer2 = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), false);
            fail("Should have hit an IOException with two IndexWriters on default SimpleFSLockFactory");
        } catch (IOException e) {
        }

        writer.close();
        if (writer2 != null) {
            writer2.close();
        }

        // Cleanup
        rmDir(indexDirName);
    }

    // Verify: FSDirectory's default lockFactory clears all locks correctly
    public void testFSDirectoryTwoCreates() throws IOException {
        String indexDirName = "index.TestLockFactory2";

        IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);

        assertTrue("FSDirectory did not use correct LockFactory: got " + writer.getDirectory().getLockFactory(),
                   SimpleFSLockFactory.class.isInstance(writer.getDirectory().getLockFactory()) ||
                   NativeFSLockFactory.class.isInstance(writer.getDirectory().getLockFactory()));

        // Intentionally do not close the first writer here.
        // The goal is to "simulate" a crashed writer and
        // ensure the second writer, with create=true, is
        // able to remove the lock files.  This works OK
        // with SimpleFSLockFactory as the locking
        // implementation.  Note, however, that this test
        // will not work on WIN32 when we switch to
        // NativeFSLockFactory as the default locking for
        // FSDirectory because the second IndexWriter cannot
        // remove those lock files since they are held open
        // by the first writer.  This is because leaving the
        // first IndexWriter open is not really a good way
        // to simulate a crashed writer.
        
        // Create a 2nd IndexWriter.  This should not fail:
        IndexWriter writer2 = null;
        try {
            writer2 = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
        } catch (IOException e) {
            e.printStackTrace(System.out);
            fail("Should not have hit an IOException with two IndexWriters with create=true, on default SimpleFSLockFactory");
        }

        writer.close();
        if (writer2 != null) {
          try {
            writer2.close();
            // expected
          } catch (LockReleaseFailedException e) {
            fail("writer2.close() should not have hit LockReleaseFailedException");
          }
        }

        // Cleanup
        rmDir(indexDirName);
    }
    

    // Verify: setting custom lock factory class (as system property) works:
    // Verify: all 4 builtin LockFactory implementations are
    //         settable this way 
    // Verify: FSDirectory does basic locking correctly
    public void testLockClassProperty() throws IOException {
        String indexDirName = "index.TestLockFactory3";
        String prpName = "org.apache.lucene.store.FSDirectoryLockFactoryClass";

        try {

          // NoLockFactory:
          System.setProperty(prpName, "org.apache.lucene.store.NoLockFactory");
          IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
          assertTrue("FSDirectory did not use correct LockFactory: got " + writer.getDirectory().getLockFactory(),
                     NoLockFactory.class.isInstance(writer.getDirectory().getLockFactory()));
          writer.close();

          // SingleInstanceLockFactory:
          System.setProperty(prpName, "org.apache.lucene.store.SingleInstanceLockFactory");
          writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
          assertTrue("FSDirectory did not use correct LockFactory: got " + writer.getDirectory().getLockFactory(),
                     SingleInstanceLockFactory.class.isInstance(writer.getDirectory().getLockFactory()));
          writer.close();

          // NativeFSLockFactory:
          System.setProperty(prpName, "org.apache.lucene.store.NativeFSLockFactory");
          writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
          assertTrue("FSDirectory did not use correct LockFactory: got " + writer.getDirectory().getLockFactory(),
                     NativeFSLockFactory.class.isInstance(writer.getDirectory().getLockFactory()));
          writer.close();

          // SimpleFSLockFactory:
          System.setProperty(prpName, "org.apache.lucene.store.SimpleFSLockFactory");
          writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
          assertTrue("FSDirectory did not use correct LockFactory: got " + writer.getDirectory().getLockFactory(),
                     SimpleFSLockFactory.class.isInstance(writer.getDirectory().getLockFactory()));
          writer.close();
        } finally {
          // Put back to the correct default for subsequent tests:
          System.setProperty("org.apache.lucene.store.FSDirectoryLockFactoryClass", "");
        }

        // Cleanup
        rmDir(indexDirName);
    }

    // Verify: setDisableLocks works
    public void testDisableLocks() throws IOException {
        String indexDirName = "index.TestLockFactory4";
        
        assertTrue("Locks are already disabled", !FSDirectory.getDisableLocks());
        FSDirectory.setDisableLocks(true);

        IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);

        assertTrue("FSDirectory did not use correct default LockFactory: got " + writer.getDirectory().getLockFactory(),
                   NoLockFactory.class.isInstance(writer.getDirectory().getLockFactory()));

        // Should be no error since locking is disabled:
        IndexWriter writer2 = null;
        try {
            writer2 = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), false);
        } catch (IOException e) {
            e.printStackTrace(System.out);
            fail("Should not have hit an IOException with locking disabled");
        }

        FSDirectory.setDisableLocks(false);
        writer.close();
        if (writer2 != null) {
            writer2.close();
        }
        // Cleanup
        rmDir(indexDirName);
    }

    // Verify: if I try to getDirectory() with two different locking implementations, I get an IOException