voldemort.store.readonly
Class ReadOnlyStorageEngine

java.lang.Object
  extended by voldemort.store.AbstractStore<K,V,T>
      extended by voldemort.store.AbstractStorageEngine<ByteArray,byte[],byte[]>
          extended by voldemort.store.readonly.ReadOnlyStorageEngine
All Implemented Interfaces:
StorageEngine<ByteArray,byte[],byte[]>, Store<ByteArray,byte[],byte[]>

public class ReadOnlyStorageEngine
extends AbstractStorageEngine<ByteArray,byte[],byte[]>

A read-only store that fronts a big file


Constructor Summary
ReadOnlyStorageEngine(java.lang.String name, SearchStrategy searchStrategy, RoutingStrategy routingStrategy, int nodeId, java.io.File storeDir, int numBackups)
          Create an instance of the store
ReadOnlyStorageEngine(java.lang.String name, SearchStrategy searchStrategy, RoutingStrategy routingStrategy, int nodeId, java.io.File storeDir, int numBackups, int deleteBackupMs)
          Create an instance of the store
ReadOnlyStorageEngine(java.lang.String name, SearchStrategy searchStrategy, RoutingStrategy routingStrategy, int nodeId, java.io.File storeDir, int numBackups, int deleteBackupMs, boolean enforceMlock)
           
 
Method Summary
 void close()
          Close the store.
 boolean delete(ByteArray key, Version version)
          Not supported, throws UnsupportedOperationException if called
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> entries()
          Get an iterator over pairs of entries in the store.
 ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> entries(int partition)
          Get an iterator over pairs of entries in a store's partition.
 java.util.List<Versioned<byte[]>> get(ByteArray key, byte[] transforms)
          Get the value associated with the given key
 java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> getAll(java.lang.Iterable<ByteArray> keys, java.util.Map<ByteArray,byte[]> transforms)
          Get the values associated with the given keys and returns them in a Map of keys to a list of versioned values.
 ChunkedFileSet getChunkedFileSet()
          Returns the internal chunked file set
 java.lang.String getChunkIdToNumChunks()
          Returns a string representation of map of chunk id to number of chunks
 java.lang.String getCurrentDirPath()
          Retrieve the absolute path of the current version
 long getCurrentVersionId()
          Retrieve the version id of the current directory
 long getLastSwapped()
          Time since last time the store was swapped
 java.lang.String getName()
           
 ReadOnlyStorageFormat getReadOnlyStorageFormat()
          Retrieve the storage format of RO
 java.lang.String getStoreDirPath()
          Retrieves the path of the store
 java.util.List<Version> getVersions(ByteArray key)
          Get the versions associated with the given key.
 boolean isPartitionAware()
          Are partitions persisted in distinct files? In other words is the data stored on disk on a per-partition basis? This is really for the read-only use case in which each partition is stored in a distinct file.
 ClosableIterator<ByteArray> keys()
          Get an iterator over keys in the store.
 ClosableIterator<ByteArray> keys(int partition)
          Get an iterator over keys in the store's partition Note that the iterator need not be threadsafe, and that it must be manually closed after use.
 void open(java.io.File versionDir)
          Open the store with the version directory specified.
 void put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
          Not supported, throws UnsupportedOperationException if called
 void rollback(java.io.File rollbackToDir)
          Rollback to the specified push version
 void rollback(java.lang.String rollbackToDir)
          Rollback to the specified push version
 void setRoutingStrategy(RoutingStrategy routingStrategy)
          Set the routing strategy required to find which partition the key belongs to
 void swapFiles(java.lang.String newStoreDirectory)
          Swap the current version folder for a new one
 void truncate()
          Truncate all entries in the store
 
Methods inherited from class voldemort.store.AbstractStorageEngine
beginBatchModifications, endBatchModifications, isPartitionScanSupported, multiVersionPut, resolveAndConstructVersionsToPersist
 
Methods inherited from class voldemort.store.AbstractStore
delete, get, getAll, getCapability, put
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 
Methods inherited from interface voldemort.store.Store
delete, get, getAll, getCapability, put
 

Constructor Detail

ReadOnlyStorageEngine

public ReadOnlyStorageEngine(java.lang.String name,
                             SearchStrategy searchStrategy,
                             RoutingStrategy routingStrategy,
                             int nodeId,
                             java.io.File storeDir,
                             int numBackups,
                             int deleteBackupMs)
Create an instance of the store

Parameters:
name - The name of the store
searchStrategy - The algorithm to use for searching for keys
routingStrategy - The routing strategy used to route keys
nodeId - Node id
storeDir - The directory in which the .data and .index files reside
numBackups - The number of backups of these files to retain
deleteBackupMs - The time in ms for which we'll wait before we delete a backup

ReadOnlyStorageEngine

public ReadOnlyStorageEngine(java.lang.String name,
                             SearchStrategy searchStrategy,
                             RoutingStrategy routingStrategy,
                             int nodeId,
                             java.io.File storeDir,
                             int numBackups)
Create an instance of the store

Parameters:
name - The name of the store
searchStrategy - The algorithm to use for searching for keys
routingStrategy - The routing strategy used to route keys
nodeId - Node id
storeDir - The directory in which the .data and .index files reside
numBackups - The number of backups of these files to retain

ReadOnlyStorageEngine

public ReadOnlyStorageEngine(java.lang.String name,
                             SearchStrategy searchStrategy,
                             RoutingStrategy routingStrategy,
                             int nodeId,
                             java.io.File storeDir,
                             int numBackups,
                             int deleteBackupMs,
                             boolean enforceMlock)
Method Detail

getChunkedFileSet

public ChunkedFileSet getChunkedFileSet()
Returns the internal chunked file set

Returns:
The chunked file set

getChunkIdToNumChunks

public java.lang.String getChunkIdToNumChunks()
Returns a string representation of map of chunk id to number of chunks

Returns:
String of map of chunk id to number of chunks

open

public void open(java.io.File versionDir)
Open the store with the version directory specified. If null is specified we open the directory with the maximum version

Parameters:
versionDir - Version Directory to open. If null, we open the max versioned / latest directory

setRoutingStrategy

public void setRoutingStrategy(RoutingStrategy routingStrategy)
Set the routing strategy required to find which partition the key belongs to


getCurrentDirPath

public java.lang.String getCurrentDirPath()
Retrieve the absolute path of the current version

Returns:
Returns the absolute path of the current dir

getCurrentVersionId

public long getCurrentVersionId()
Retrieve the version id of the current directory

Returns:
Returns a long indicating the version number

getStoreDirPath

public java.lang.String getStoreDirPath()
Retrieves the path of the store

Returns:
The absolute path of the store

getReadOnlyStorageFormat

public ReadOnlyStorageFormat getReadOnlyStorageFormat()
Retrieve the storage format of RO

Returns:
The type of the storage format

getLastSwapped

public long getLastSwapped()
Time since last time the store was swapped

Returns:
Time in milliseconds since the store was swapped

close

public void close()
           throws VoldemortException
Close the store.

Specified by:
close in interface Store<ByteArray,byte[],byte[]>
Overrides:
close in class AbstractStore<ByteArray,byte[],byte[]>
Throws:
VoldemortException - If closing fails.

swapFiles

public void swapFiles(java.lang.String newStoreDirectory)
Swap the current version folder for a new one

Parameters:
newStoreDirectory - The path to the new version directory

rollback

public void rollback(java.lang.String rollbackToDir)
Rollback to the specified push version

Parameters:
rollbackToDir - The full path of the version directory to rollback to

rollback

public void rollback(java.io.File rollbackToDir)
Rollback to the specified push version

Parameters:
rollbackToDir - The version directory to rollback to

keys

public ClosableIterator<ByteArray> keys()
Description copied from interface: StorageEngine
Get an iterator over keys in the store. Note that the iterator need not be threadsafe, and that it must be manually closed after use.

Specified by:
keys in interface StorageEngine<ByteArray,byte[],byte[]>
Overrides:
keys in class AbstractStorageEngine<ByteArray,byte[],byte[]>
Returns:
An iterator over the keys in this StorageEngine.

entries

public ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> entries()
Description copied from interface: StorageEngine
Get an iterator over pairs of entries in the store. The key is the first element in the pair and the versioned value is the second element. Note that the iterator need not be threadsafe, and that it must be manually closed after use.

Specified by:
entries in interface StorageEngine<ByteArray,byte[],byte[]>
Overrides:
entries in class AbstractStorageEngine<ByteArray,byte[],byte[]>
Returns:
An iterator over the entries in this StorageEngine.

entries

public ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> entries(int partition)
Description copied from interface: StorageEngine
Get an iterator over pairs of entries in a store's partition. The key is the first element in the pair and the versioned value is the second element. Note that the iterator need not be threadsafe, and that it must be manually closed after use.

Specified by:
entries in interface StorageEngine<ByteArray,byte[],byte[]>
Overrides:
entries in class AbstractStorageEngine<ByteArray,byte[],byte[]>
Parameters:
partition - partition whose entries are to be fetched
Returns:
An iterator over the entries in this StorageEngine.

keys

public ClosableIterator<ByteArray> keys(int partition)
Description copied from interface: StorageEngine
Get an iterator over keys in the store's partition Note that the iterator need not be threadsafe, and that it must be manually closed after use.

Specified by:
keys in interface StorageEngine<ByteArray,byte[],byte[]>
Overrides:
keys in class AbstractStorageEngine<ByteArray,byte[],byte[]>
Parameters:
partition - partition whose keys are to be fetched
Returns:
An iterator over the keys in this StorageEngine.

truncate

public void truncate()
Description copied from interface: StorageEngine
Truncate all entries in the store

Specified by:
truncate in interface StorageEngine<ByteArray,byte[],byte[]>
Overrides:
truncate in class AbstractStorageEngine<ByteArray,byte[],byte[]>

get

public java.util.List<Versioned<byte[]>> get(ByteArray key,
                                             byte[] transforms)
                                      throws VoldemortException
Description copied from interface: Store
Get the value associated with the given key

Specified by:
get in interface Store<ByteArray,byte[],byte[]>
Overrides:
get in class AbstractStore<ByteArray,byte[],byte[]>
Parameters:
key - The key to check for
Returns:
The value associated with the key or an empty list if no values are found.
Throws:
VoldemortException

getAll

public java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> getAll(java.lang.Iterable<ByteArray> keys,
                                                                         java.util.Map<ByteArray,byte[]> transforms)
                                                                  throws VoldemortException
Description copied from interface: Store
Get the values associated with the given keys and returns them in a Map of keys to a list of versioned values. Note that the returned map will only contain entries for the keys which have a value associated with them.

Specified by:
getAll in interface Store<ByteArray,byte[],byte[]>
Overrides:
getAll in class AbstractStore<ByteArray,byte[],byte[]>
Parameters:
keys - The keys to check for.
Returns:
A Map of keys to a list of versioned values.
Throws:
VoldemortException

delete

public boolean delete(ByteArray key,
                      Version version)
               throws VoldemortException
Not supported, throws UnsupportedOperationException if called

Specified by:
delete in interface Store<ByteArray,byte[],byte[]>
Overrides:
delete in class AbstractStore<ByteArray,byte[],byte[]>
Parameters:
key - The key to delete
version - The current value of the key
Returns:
True if anything was deleted
Throws:
VoldemortException

put

public void put(ByteArray key,
                Versioned<byte[]> value,
                byte[] transforms)
         throws VoldemortException
Not supported, throws UnsupportedOperationException if called

Specified by:
put in interface Store<ByteArray,byte[],byte[]>
Overrides:
put in class AbstractStore<ByteArray,byte[],byte[]>
Parameters:
key - The key to use
value - The value to store and its version.
Throws:
VoldemortException

getName

public java.lang.String getName()
Specified by:
getName in interface Store<ByteArray,byte[],byte[]>
Overrides:
getName in class AbstractStore<ByteArray,byte[],byte[]>
Returns:
The name of the store.

getVersions

public java.util.List<Version> getVersions(ByteArray key)
Description copied from interface: Store
Get the versions associated with the given key. This is used in a put call to write a new value for this key

Specified by:
getVersions in interface Store<ByteArray,byte[],byte[]>
Overrides:
getVersions in class AbstractStore<ByteArray,byte[],byte[]>
Parameters:
key - The key to retrieve the versions for
Returns:
List of Versions associated with this key.

isPartitionAware

public boolean isPartitionAware()
Description copied from interface: StorageEngine
Are partitions persisted in distinct files? In other words is the data stored on disk on a per-partition basis? This is really for the read-only use case in which each partition is stored in a distinct file.

Specified by:
isPartitionAware in interface StorageEngine<ByteArray,byte[],byte[]>
Overrides:
isPartitionAware in class AbstractStorageEngine<ByteArray,byte[],byte[]>
Returns:
Boolean indicating if partitions are persisted in distinct files (read-only use case).


Jay Kreps, Roshan Sumbaly, Alex Feinberg, Bhupesh Bansal, Lei Gao, Chinmay Soman, Vinoth Chandar, Zhongjie Wu