org.apache.lucene.index
Class PersistentSnapshotDeletionPolicy

java.lang.Object
  org.apache.lucene.index.SnapshotDeletionPolicy
      org.apache.lucene.index.PersistentSnapshotDeletionPolicy

All Implemented Interfaces:

IndexDeletionPolicy

public class PersistentSnapshotDeletionPolicy
extends SnapshotDeletionPolicy

A SnapshotDeletionPolicy which adds a persistence layer so that snapshots can be maintained across the life of an application. The snapshots are persisted in a Directory and are committed as soon as snapshot(String) or release(String) is called.

NOTE: this class receives a Directory to persist the data into a Lucene index. It is highly recommended to use a dedicated directory (and on stable storage as well) for persisting the snapshots' information, and not reuse the content index directory, or otherwise conflicts and index corruptions will occur.

NOTE: you should call close() when you're done using this class for safetyness (it will close the IndexWriter instance used).

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.lucene.index.SnapshotDeletionPolicy

SnapshotDeletionPolicy.SnapshotCommitPoint

Field Summary

Fields inherited from class org.apache.lucene.index.SnapshotDeletionPolicy

lastCommit

Constructor Summary

PersistentSnapshotDeletionPolicy(IndexDeletionPolicy primary, Directory dir, IndexWriterConfig.OpenMode mode, Version matchVersion)
PersistentSnapshotDeletionPolicy wraps another IndexDeletionPolicy to enable flexible snapshotting.

Method Summary

void	close() Closes the index which writes the snapshots to the directory.
void	onInit(List<? extends IndexCommit> commits) This is called once when a writer is first instantiated to give the policy a chance to remove old commit points.
static Map<String,String>	readSnapshotsInfo(Directory dir) Reads the snapshots information from the given Directory.
void	release(String id) Deletes a snapshotted commit by ID.
IndexCommit	snapshot(String id) Snapshots the last commit using the given ID.

Methods inherited from class org.apache.lucene.index.SnapshotDeletionPolicy

checkSnapshotted, getSnapshot, getSnapshots, isSnapshotted, onCommit, registerSnapshotInfo, wrapCommits

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

PersistentSnapshotDeletionPolicy

public PersistentSnapshotDeletionPolicy(IndexDeletionPolicy primary,
                                        Directory dir,
                                        IndexWriterConfig.OpenMode mode,
                                        Version matchVersion)
                                 throws CorruptIndexException,
                                        LockObtainFailedException,
                                        IOException

PersistentSnapshotDeletionPolicy wraps another IndexDeletionPolicy to enable flexible snapshotting.

Parameters:

primary - the IndexDeletionPolicy that is used on non-snapshotted commits. Snapshotted commits, by definition, are not deleted until explicitly released via release(String).

dir - the Directory which will be used to persist the snapshots information.

mode - specifies whether a new index should be created, deleting all existing snapshots information (immediately), or open an existing index, initializing the class with the snapshots information.

matchVersion - specifies the Version that should be used when opening the IndexWriter.

Throws:

CorruptIndexException

LockObtainFailedException

IOException

Method Detail

readSnapshotsInfo

public static Map<String,String> readSnapshotsInfo(Directory dir)
                                            throws IOException

Reads the snapshots information from the given Directory. This method can be used if the snapshots information is needed, however you cannot instantiate the deletion policy (because e.g., some other process keeps a lock on the snapshots directory).

Throws:

IOException

onInit

public void onInit(List<? extends IndexCommit> commits)
            throws IOException

Description copied from interface: IndexDeletionPolicy

This is called once when a writer is first instantiated to give the policy a chance to remove old commit points.

The writer locates all index commits present in the index directory and calls this method. The policy may choose to delete some of the commit points, doing so by calling method delete() of IndexCommit.

Note: the last CommitPoint is the most recent one, i.e. the "front index state". Be careful not to delete it, unless you know for sure what you are doing, and unless you can afford to lose the index content while doing that.

Specified by:

onInit in interface IndexDeletionPolicy

Overrides:

onInit in class SnapshotDeletionPolicy

Parameters:

commits - List of current point-in-time commits, sorted by age (the 0th one is the oldest commit).

Throws:

IOException

snapshot

public IndexCommit snapshot(String id)
                     throws IOException

Snapshots the last commit using the given ID. Once this method returns, the snapshot information is persisted in the directory.

Overrides:

snapshot in class SnapshotDeletionPolicy

Parameters:

id - a unique identifier of the commit that is being snapshotted.

Returns:

the IndexCommit that was snapshotted.

Throws:

IOException

See Also:

SnapshotDeletionPolicy.snapshot(String)

release

public void release(String id)
             throws IOException

Deletes a snapshotted commit by ID. Once this method returns, the snapshot information is committed to the directory.

Overrides:

release in class SnapshotDeletionPolicy

Parameters:

id - a unique identifier of the commit that is un-snapshotted.

Throws:

IOException

See Also:

SnapshotDeletionPolicy.release(String)

close

public void close()
           throws CorruptIndexException,
                  IOException

Closes the index which writes the snapshots to the directory.

Throws:

CorruptIndexException

IOException