|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use ByteArray | |
---|---|
voldemort.client | The user facing interface to Voldemort. |
voldemort.client.protocol | Classes that abstract the serialization format for Voldemort client requests. |
voldemort.client.protocol.admin | Classes that abstract admin based Voldemort requests. |
voldemort.client.protocol.pb | A protocol buffers based client-side request format. |
voldemort.client.protocol.vold | Classes specific to our native Voldemort protocol. |
voldemort.cluster.failuredetector | Classes associated with client side failure detectors. |
voldemort.rest | |
voldemort.rest.coordinator | |
voldemort.rest.server | |
voldemort.serialization | Code for mapping objects to bytes and bytes to objects. |
voldemort.server | The Voldemort server. |
voldemort.server.protocol | The server side of request RPC handling. |
voldemort.server.protocol.admin | Server side implementation of admin based requests |
voldemort.server.scheduler.slop | The background jobs associated with the slop store. |
voldemort.server.storage | The storage service which handles instantiating all the stores and their corresponding engines. |
voldemort.store | The Store interface is the primary interface for Voldemort. |
voldemort.store.bdb | A storage engine that persists data in BDB JE. |
voldemort.store.compress | Classes associated with compression on the server ( storage ) side. |
voldemort.store.configuration | A storage engine to persist metadata on a server. |
voldemort.store.http | HTTP based storage engine |
voldemort.store.invalidmetadata | Server side store which checks whether the tuples coming to this node are valid. |
voldemort.store.memory | An in-memory storage engine that serves data out of a non-persistent map. |
voldemort.store.metadata | Our in-memory metadata store on the server which is backed by the configuration files. |
voldemort.store.mysql | A storage engine that persists data in a mysql instance. |
voldemort.store.nonblockingstore | Non-blocking store which deals with async requests. |
voldemort.store.quota | |
voldemort.store.readonly | A storage engine that provides very efficient read-only access to large sorted files of data. |
voldemort.store.readonly.chunk | Read-only store classes for understanding various format changes. |
voldemort.store.rebalancing | Server side wrapper stores used for redirection during rebalancing. |
voldemort.store.retention | |
voldemort.store.routed | A store implmentation that handles routing to nodes, and repairing obsolete values detected on those nodes. |
voldemort.store.routed.action | Classes representing various states for the state based routing stores. |
voldemort.store.serialized | A store implementation that handles serialization to bytes from rich objects. |
voldemort.store.slop | A store implementation that falls back on storing values in additional nodes not in the preference list when nodes are unavailable. |
voldemort.store.socket | A store implementation that works remotely over a tcp/ip socket interacting with a SocketServer on the the other side. |
voldemort.store.socket.clientrequest | More classes related to how to parse client requests |
voldemort.store.stats | Store wrappers which deal with statistics |
voldemort.store.views | Classes related to Views and server side transforms |
voldemort.tools | Tools used for administrating a cluster. |
voldemort.utils | Basic helper functions. |
Uses of ByteArray in voldemort.client |
---|
Methods in voldemort.client that return types with arguments of type ByteArray | |
---|---|
protected abstract Store<ByteArray,byte[],byte[]> |
AbstractStoreClientFactory.getStore(java.lang.String storeName,
java.lang.String host,
int port,
RequestFormatType type)
|
protected Store<ByteArray,byte[],byte[]> |
SocketStoreClientFactory.getStore(java.lang.String storeName,
java.lang.String host,
int port,
RequestFormatType type)
|
protected Store<ByteArray,byte[],byte[]> |
HttpStoreClientFactory.getStore(java.lang.String name,
java.lang.String host,
int port,
RequestFormatType type)
Deprecated. |
Uses of ByteArray in voldemort.client.protocol |
---|
Methods in voldemort.client.protocol that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
RequestFormat.readGetAllResponse(java.io.DataInputStream stream)
|
Methods in voldemort.client.protocol with parameters of type ByteArray | |
---|---|
void |
RequestFormat.writeDeleteRequest(java.io.DataOutputStream output,
java.lang.String storeName,
ByteArray key,
VectorClock version,
RequestRoutingType routingType)
|
void |
RequestFormat.writeGetRequest(java.io.DataOutputStream output,
java.lang.String storeName,
ByteArray key,
byte[] transforms,
RequestRoutingType routingType)
|
void |
RequestFormat.writeGetVersionRequest(java.io.DataOutputStream output,
java.lang.String storeName,
ByteArray key,
RequestRoutingType routingType)
|
void |
RequestFormat.writePutRequest(java.io.DataOutputStream output,
java.lang.String storeName,
ByteArray key,
byte[] value,
byte[] transforms,
VectorClock version,
RequestRoutingType routingType)
|
Method parameters in voldemort.client.protocol with type arguments of type ByteArray | |
---|---|
void |
RequestFormat.writeGetAllRequest(java.io.DataOutputStream output,
java.lang.String storeName,
java.lang.Iterable<ByteArray> key,
java.util.Map<ByteArray,byte[]> transforms,
RequestRoutingType routingType)
|
void |
RequestFormat.writeGetAllRequest(java.io.DataOutputStream output,
java.lang.String storeName,
java.lang.Iterable<ByteArray> key,
java.util.Map<ByteArray,byte[]> transforms,
RequestRoutingType routingType)
|
Uses of ByteArray in voldemort.client.protocol.admin |
---|
Methods in voldemort.client.protocol.admin that return ByteArray | |
---|---|
ByteArray |
QueryKeyResult.getKey()
|
Methods in voldemort.client.protocol.admin that return types with arguments of type ByteArray | |
---|---|
java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> |
AdminClient.BulkStreamingFetchOperations.fetchEntries(int nodeId,
java.lang.String storeName,
java.util.List<java.lang.Integer> partitionList,
VoldemortFilter filter,
boolean fetchMasterEntries)
Legacy interface for fetching entries. |
java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> |
AdminClient.BulkStreamingFetchOperations.fetchEntries(int nodeId,
java.lang.String storeName,
java.util.List<java.lang.Integer> partitionIds,
VoldemortFilter filter,
boolean fetchMasterEntries,
Cluster initialCluster,
long recordsPerPartition)
Fetch key/value tuples belonging to this list of partition ids |
java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> |
AdminClient.BulkStreamingFetchOperations.fetchEntries(int nodeId,
java.lang.String storeName,
java.util.List<java.lang.Integer> partitionIds,
VoldemortFilter filter,
boolean fetchMasterEntries,
long recordsPerPartition)
Legacy interface for fetching entries. |
java.util.Iterator<ByteArray> |
AdminClient.BulkStreamingFetchOperations.fetchKeys(int nodeId,
java.lang.String storeName,
java.util.List<java.lang.Integer> partitionList,
VoldemortFilter filter,
boolean fetchMasterEntries)
Legacy interface for fetching entries. |
java.util.Iterator<ByteArray> |
AdminClient.BulkStreamingFetchOperations.fetchKeys(int nodeId,
java.lang.String storeName,
java.util.List<java.lang.Integer> partitionIds,
VoldemortFilter filter,
boolean fetchMasterEntries,
Cluster initialCluster,
long recordsPerPartition)
Fetch all keys belonging to the list of partition ids. |
java.util.Iterator<ByteArray> |
AdminClient.BulkStreamingFetchOperations.fetchKeys(int nodeId,
java.lang.String storeName,
java.util.List<java.lang.Integer> partitionIds,
VoldemortFilter filter,
boolean fetchMasterEntries,
long recordsPerPartition)
Legacy interface for fetching entries. |
java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> |
AdminClient.BulkStreamingFetchOperations.fetchOrphanedEntries(int nodeId,
java.lang.String storeName)
Fetches entries that don't belong to the node, based on current metadata and yet persisted on the node |
java.util.Iterator<ByteArray> |
AdminClient.BulkStreamingFetchOperations.fetchOrphanedKeys(int nodeId,
java.lang.String storeName)
Fetch all the keys on the node that don't belong to it, based on its current metadata and yet stored on the node. |
Methods in voldemort.client.protocol.admin with parameters of type ByteArray | |
---|---|
java.util.List<Versioned<byte[]>> |
AdminClient.StoreOperations.getNodeKey(java.lang.String storeName,
int nodeId,
ByteArray key)
Fetch key/value tuple for given key for a specific store on specified node. |
void |
BaseStreamingClient.streamingPut(ByteArray key,
Versioned<byte[]> value)
A Streaming Put call |
void |
BaseStreamingClient.streamingPut(ByteArray key,
Versioned<byte[]> value,
java.lang.String storeName)
|
void |
StreamingClient.streamingPut(ByteArray key,
Versioned<byte[]> value,
java.lang.String storeName)
|
protected void |
StreamingClient.streamingSlopPut(ByteArray key,
Versioned<byte[]> value,
java.lang.String storeName,
int failedNodeId)
This is a method to stream slops to "slop" store when a node is detected faulty in a streaming session |
Method parameters in voldemort.client.protocol.admin with type arguments of type ByteArray | |
---|---|
void |
AdminClient.StoreOperations.putNodeKeyValue(java.lang.String storeName,
NodeValue<ByteArray,byte[]> nodeKeyValue)
This method updates exactly one key/value for a specific store on a specific node. |
java.util.Iterator<QueryKeyResult> |
AdminClient.StreamingOperations.queryKeys(int nodeId,
java.lang.String storeName,
java.util.Iterator<ByteArray> keys)
Fetch key/value tuples from a given server, directly from storage engine |
void |
AdminClient.StreamingOperations.updateEntries(int nodeId,
java.lang.String storeName,
java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> entryIterator,
VoldemortFilter filter)
Update a stream of key/value entries at the given node. |
void |
AdminClient.StreamingOperations.updateEntriesTimeBased(int nodeId,
java.lang.String storeName,
java.util.Iterator<Pair<ByteArray,Versioned<byte[]>>> entryIterator,
VoldemortFilter filter)
Update a stream of key/value entries at the given node in the same way as AdminClient.StreamingOperations.updateEntries(int, String, Iterator, VoldemortFilter)
The only difference being the resolving on the server will happen
based on timestamp and not the vector clock. |
Constructors in voldemort.client.protocol.admin with parameters of type ByteArray | |
---|---|
QueryKeyResult(ByteArray key,
java.lang.Exception exception)
|
|
QueryKeyResult(ByteArray key,
java.util.List<Versioned<byte[]>> values)
|
Uses of ByteArray in voldemort.client.protocol.pb |
---|
Methods in voldemort.client.protocol.pb that return ByteArray | |
---|---|
static ByteArray |
ProtoUtils.decodeBytes(com.google.protobuf.ByteString string)
|
Methods in voldemort.client.protocol.pb that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
ProtoBuffClientRequestFormat.readGetAllResponse(java.io.DataInputStream input)
|
Methods in voldemort.client.protocol.pb with parameters of type ByteArray | |
---|---|
static com.google.protobuf.ByteString |
ProtoUtils.encodeBytes(ByteArray array)
|
void |
ProtoBuffClientRequestFormat.writeDeleteRequest(java.io.DataOutputStream output,
java.lang.String storeName,
ByteArray key,
VectorClock version,
RequestRoutingType routingType)
|
void |
ProtoBuffClientRequestFormat.writeGetRequest(java.io.DataOutputStream output,
java.lang.String storeName,
ByteArray key,
byte[] transforms,
RequestRoutingType routingType)
|
void |
ProtoBuffClientRequestFormat.writeGetVersionRequest(java.io.DataOutputStream output,
java.lang.String storeName,
ByteArray key,
RequestRoutingType routingType)
|
void |
ProtoBuffClientRequestFormat.writePutRequest(java.io.DataOutputStream output,
java.lang.String storeName,
ByteArray key,
byte[] value,
byte[] transforms,
VectorClock version,
RequestRoutingType routingType)
|
Method parameters in voldemort.client.protocol.pb with type arguments of type ByteArray | |
---|---|
void |
ProtoBuffClientRequestFormat.writeGetAllRequest(java.io.DataOutputStream output,
java.lang.String storeName,
java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
RequestRoutingType routingType)
|
void |
ProtoBuffClientRequestFormat.writeGetAllRequest(java.io.DataOutputStream output,
java.lang.String storeName,
java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
RequestRoutingType routingType)
|
Uses of ByteArray in voldemort.client.protocol.vold |
---|
Methods in voldemort.client.protocol.vold that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
VoldemortNativeClientRequestFormat.readGetAllResponse(java.io.DataInputStream stream)
|
Methods in voldemort.client.protocol.vold with parameters of type ByteArray | |
---|---|
void |
VoldemortNativeClientRequestFormat.writeDeleteRequest(java.io.DataOutputStream outputStream,
java.lang.String storeName,
ByteArray key,
VectorClock version,
RequestRoutingType routingType)
|
void |
VoldemortNativeClientRequestFormat.writeGetRequest(java.io.DataOutputStream outputStream,
java.lang.String storeName,
ByteArray key,
byte[] transforms,
RequestRoutingType routingType)
|
void |
VoldemortNativeClientRequestFormat.writeGetVersionRequest(java.io.DataOutputStream output,
java.lang.String storeName,
ByteArray key,
RequestRoutingType routingType)
|
void |
VoldemortNativeClientRequestFormat.writePutRequest(java.io.DataOutputStream outputStream,
java.lang.String storeName,
ByteArray key,
byte[] value,
byte[] transforms,
VectorClock version,
RequestRoutingType routingType)
|
Method parameters in voldemort.client.protocol.vold with type arguments of type ByteArray | |
---|---|
void |
VoldemortNativeClientRequestFormat.writeGetAllRequest(java.io.DataOutputStream output,
java.lang.String storeName,
java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
RequestRoutingType routingType)
|
void |
VoldemortNativeClientRequestFormat.writeGetAllRequest(java.io.DataOutputStream output,
java.lang.String storeName,
java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
RequestRoutingType routingType)
|
Uses of ByteArray in voldemort.cluster.failuredetector |
---|
Fields in voldemort.cluster.failuredetector declared as ByteArray | |
---|---|
static ByteArray |
StoreVerifier.KEY
|
Methods in voldemort.cluster.failuredetector that return types with arguments of type ByteArray | |
---|---|
protected abstract Store<ByteArray,byte[],byte[]> |
ClientStoreVerifier.getStoreInternal(Node node)
|
Uses of ByteArray in voldemort.rest |
---|
Fields in voldemort.rest with type parameters of type ByteArray | |
---|---|
protected java.util.List<ByteArray> |
RestRequestValidator.parsedKeys
|
protected CompositeVoldemortRequest<ByteArray,byte[]> |
RestRequestValidator.requestObject
|
Methods in voldemort.rest that return types with arguments of type ByteArray | |
---|---|
CompositeVoldemortRequest<ByteArray,byte[]> |
RestPutRequestValidator.constructCompositeVoldemortRequestObject()
|
CompositeVoldemortRequest<ByteArray,byte[]> |
RestGetRequestValidator.constructCompositeVoldemortRequestObject()
|
abstract CompositeVoldemortRequest<ByteArray,byte[]> |
RestRequestValidator.constructCompositeVoldemortRequestObject()
|
CompositeVoldemortRequest<ByteArray,byte[]> |
RestDeleteRequestValidator.constructCompositeVoldemortRequestObject()
|
Methods in voldemort.rest with parameters of type ByteArray | |
---|---|
static java.lang.String |
RestUtils.getKeyHexString(ByteArray key)
|
Method parameters in voldemort.rest with type arguments of type ByteArray | |
---|---|
static java.lang.String |
RestUtils.getKeysHexString(java.util.Iterator<ByteArray> keys)
|
protected java.lang.String |
RestResponseSender.getKeysHexString(java.util.Set<ByteArray> keys)
|
protected java.lang.String |
RestRequestValidator.keysHexString(java.util.List<ByteArray> keys)
|
Constructors in voldemort.rest with parameters of type ByteArray | |
---|---|
DeleteResponseSender(org.jboss.netty.channel.MessageEvent messageEvent,
java.lang.String storeName,
ByteArray key)
Constructor called by coordinator worker thread |
|
GetResponseSender(org.jboss.netty.channel.MessageEvent messageEvent,
ByteArray key,
java.util.List<Versioned<byte[]>> versionedValues,
java.lang.String storeName)
|
|
GetVersionResponseSender(org.jboss.netty.channel.MessageEvent messageEvent,
ByteArray key,
java.util.List<Version> versionedValues,
java.lang.String storeName)
|
|
PutResponseSender(org.jboss.netty.channel.MessageEvent messageEvent,
VectorClock successfulPutVC,
java.lang.String storeName,
ByteArray key)
Constructor called by Coordinator worker thread |
Constructor parameters in voldemort.rest with type arguments of type ByteArray | |
---|---|
GetAllResponseSender(org.jboss.netty.channel.MessageEvent messageEvent,
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> versionedResponses,
java.lang.String storeName)
|
Uses of ByteArray in voldemort.rest.coordinator |
---|
Methods in voldemort.rest.coordinator that return types with arguments of type ByteArray | |
---|---|
CompositeVoldemortRequest<ByteArray,byte[]> |
CoordinatorStoreClientRequest.getRequestObject()
|
DynamicTimeoutStoreClient<ByteArray,byte[]> |
CoordinatorStoreClientRequest.getStoreClient()
|
Method parameters in voldemort.rest.coordinator with type arguments of type ByteArray | |
---|---|
protected java.lang.String |
DynamicTimeoutStoreClient.getKeysHexString(java.lang.Iterable<ByteArray> keys)
|
Constructor parameters in voldemort.rest.coordinator with type arguments of type ByteArray | |
---|---|
CoordinatorPipelineFactory(java.util.Map<java.lang.String,DynamicTimeoutStoreClient<ByteArray,byte[]>> fatClientMap,
CoordinatorMetadata coordinatorMetadata,
CoordinatorConfig config,
StoreStats coordinatorPerfStats,
NettyConnectionStats connectionStats)
|
|
CoordinatorStoreClientRequest(CompositeVoldemortRequest<ByteArray,byte[]> requestObject,
DynamicTimeoutStoreClient<ByteArray,byte[]> storeClient)
|
|
CoordinatorStoreClientRequest(CompositeVoldemortRequest<ByteArray,byte[]> requestObject,
DynamicTimeoutStoreClient<ByteArray,byte[]> storeClient)
|
|
RestCoordinatorRequestHandler(java.util.Map<java.lang.String,DynamicTimeoutStoreClient<ByteArray,byte[]>> fatClientMap)
|
Uses of ByteArray in voldemort.rest.server |
---|
Methods in voldemort.rest.server that return types with arguments of type ByteArray | |
---|---|
CompositeVoldemortRequest<ByteArray,byte[]> |
VoldemortStoreRequest.getRequestObject()
|
Store<ByteArray,byte[],byte[]> |
VoldemortStoreRequest.getStore()
|
protected Store<ByteArray,byte[],byte[]> |
RestServerRequestHandler.getStore(java.lang.String name,
RequestRoutingType type)
Gets the store for the store name and routing type. |
Constructor parameters in voldemort.rest.server with type arguments of type ByteArray | |
---|---|
VoldemortStoreRequest(CompositeVoldemortRequest<ByteArray,byte[]> requestObject,
Store<ByteArray,byte[],byte[]> store,
int zoneId)
|
|
VoldemortStoreRequest(CompositeVoldemortRequest<ByteArray,byte[]> requestObject,
Store<ByteArray,byte[],byte[]> store,
int zoneId)
|
Uses of ByteArray in voldemort.serialization |
---|
Methods in voldemort.serialization that return ByteArray | |
---|---|
ByteArray |
ByteArraySerializer.toObject(byte[] bytes)
|
Methods in voldemort.serialization with parameters of type ByteArray | |
---|---|
byte[] |
ByteArraySerializer.toBytes(ByteArray object)
|
Uses of ByteArray in voldemort.server |
---|
Methods in voldemort.server that return types with arguments of type ByteArray | |
---|---|
java.util.List<Store<ByteArray,byte[],byte[]>> |
StoreRepository.getAllLocalStores()
|
java.util.List<Pair<java.lang.Integer,Store<ByteArray,byte[],byte[]>>> |
StoreRepository.getAllNodeStores()
|
java.util.List<Store<ByteArray,byte[],byte[]>> |
StoreRepository.getAllRoutedStores()
|
java.util.List<StorageEngine<ByteArray,byte[],byte[]>> |
StoreRepository.getAllStorageEngines()
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.getLocalStore(java.lang.String storeName)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.getNodeStore(java.lang.String storeName,
java.lang.Integer id)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.getRedirectingSocketStore(java.lang.String storeName,
java.lang.Integer id)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.getRoutedStore(java.lang.String storeName)
|
StorageEngine<ByteArray,byte[],byte[]> |
StoreRepository.getStorageEngine(java.lang.String storeName)
|
java.util.List<StorageEngine<ByteArray,byte[],byte[]>> |
StoreRepository.getStorageEnginesByClass(java.lang.Class<? extends StorageEngine<?,?,?>> c)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.removeLocalStore(java.lang.String storeName)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.removeNodeStore(java.lang.String storeName,
int nodeId)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.removeRoutedStore(java.lang.String storeName)
|
Store<ByteArray,byte[],byte[]> |
StoreRepository.removeStorageEngine(java.lang.String storeName)
|
Method parameters in voldemort.server with type arguments of type ByteArray | |
---|---|
void |
StoreRepository.addLocalStore(Store<ByteArray,byte[],byte[]> store)
|
void |
StoreRepository.addNodeStore(int nodeId,
Store<ByteArray,byte[],byte[]> store)
|
void |
StoreRepository.addRedirectingSocketStore(int nodeId,
Store<ByteArray,byte[],byte[]> store)
|
void |
StoreRepository.addRoutedStore(Store<ByteArray,byte[],byte[]> store)
|
void |
StoreRepository.addStorageEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
|
Uses of ByteArray in voldemort.server.protocol |
---|
Methods in voldemort.server.protocol that return types with arguments of type ByteArray | |
---|---|
protected Store<ByteArray,byte[],byte[]> |
AbstractRequestHandler.getStore(java.lang.String name,
RequestRoutingType type)
|
Uses of ByteArray in voldemort.server.protocol.admin |
---|
Fields in voldemort.server.protocol.admin with type parameters of type ByteArray | |
---|---|
protected ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
PartitionScanFetchEntriesRequestHandler.entriesPartitionIterator
|
protected ClosableIterator<ByteArray> |
FullScanFetchStreamRequestHandler.keyIterator
|
protected ClosableIterator<ByteArray> |
PartitionScanFetchKeysRequestHandler.keysPartitionIterator
|
protected StorageEngine<ByteArray,byte[],byte[]> |
FetchStreamRequestHandler.storageEngine
|
protected StorageEngine<ByteArray,byte[],byte[]> |
UpdatePartitionEntriesStreamRequestHandler.storageEngine
|
Methods in voldemort.server.protocol.admin with parameters of type ByteArray | |
---|---|
protected void |
TimeBasedUpdatePartitionEntriesStreamRequestHandler.processEntry(ByteArray key,
Versioned<byte[]> value)
|
protected void |
UpdatePartitionEntriesStreamRequestHandler.processEntry(ByteArray key,
Versioned<byte[]> value)
|
Constructor parameters in voldemort.server.protocol.admin with type arguments of type ByteArray | |
---|---|
TimeBasedUpdatePartitionEntriesStreamRequestHandler(VAdminProto.UpdatePartitionEntriesRequest request,
ErrorCodeMapper errorCodeMapper,
VoldemortConfig voldemortConfig,
StorageEngine<ByteArray,byte[],byte[]> storageEngine,
StoreRepository storeRepository,
NetworkClassLoader networkClassLoader)
|
|
UpdatePartitionEntriesStreamRequestHandler(VAdminProto.UpdatePartitionEntriesRequest request,
ErrorCodeMapper errorCodeMapper,
VoldemortConfig voldemortConfig,
StorageEngine<ByteArray,byte[],byte[]> storageEngine,
StoreRepository storeRepository,
NetworkClassLoader networkClassLoader)
|
Uses of ByteArray in voldemort.server.scheduler.slop |
---|
Method parameters in voldemort.server.scheduler.slop with type arguments of type ByteArray | |
---|---|
protected void |
SlopPusherJob.handleDeadSlop(SlopStorageEngine slopStorageEngine,
Pair<ByteArray,Versioned<Slop>> keyAndVal)
Handle slop for nodes that are no longer part of the cluster. |
Uses of ByteArray in voldemort.server.storage |
---|
Fields in voldemort.server.storage with type parameters of type ByteArray | |
---|---|
protected ClosableIterator<ByteArray> |
DataMaintenanceJob.iterator
|
Methods in voldemort.server.storage that return types with arguments of type ByteArray | |
---|---|
StorageEngine<ByteArray,byte[],byte[]> |
StorageService.openStore(StoreDefinition storeDef)
|
Method parameters in voldemort.server.storage with type arguments of type ByteArray | |
---|---|
protected void |
DataMaintenanceJob.closeIterator(ClosableIterator<ByteArray> iterator)
|
void |
StorageService.registerEngine(StorageEngine<ByteArray,byte[],byte[]> engine,
boolean isReadOnly,
java.lang.String storeType,
StoreDefinition storeDef)
Register the given engine with the storage repository |
void |
StorageService.registerInternalEngine(StorageEngine<ByteArray,byte[],byte[]> engine,
boolean isReadOnly,
java.lang.String storeType)
Register the given internal engine (slop and metadata) with the storage repository |
void |
StorageService.registerSystemEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
|
void |
StorageService.removeEngine(StorageEngine<ByteArray,byte[],byte[]> engine,
boolean isReadOnly,
java.lang.String storeType,
boolean truncate)
Unregister and remove the engine from the storage repository. |
void |
StorageService.unregisterSystemEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
|
Uses of ByteArray in voldemort.store |
---|
Methods in voldemort.store that return types with arguments of type ByteArray | |
---|---|
StorageEngine<ByteArray,byte[],byte[]> |
StorageConfiguration.getStore(StoreDefinition storeDef,
RoutingStrategy strategy)
Get an initialized storage implementation |
Pair<ByteArray,Versioned<byte[]>> |
PartitionListIterator.next()
|
Methods in voldemort.store with parameters of type ByteArray | |
---|---|
static void |
StoreUtils.assertValidMetadata(ByteArray key,
RoutingStrategy routingStrategy,
Node currentNode)
Check if the current node is part of routing request based on cluster.xml or throw an exception. |
Method parameters in voldemort.store with type arguments of type ByteArray | |
---|---|
void |
StorageConfiguration.removeStorageEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
Remove the storage engine from the underlying storage configuration |
T |
StoreRequest.request(Store<ByteArray,byte[],byte[]> store)
Perform the request to the given Store . |
Constructor parameters in voldemort.store with type arguments of type ByteArray | |
---|---|
PartitionListIterator(StorageEngine<ByteArray,byte[],byte[]> storageEngine,
java.util.List<java.lang.Integer> partitionsToFetch)
|
Uses of ByteArray in voldemort.store.bdb |
---|
Methods in voldemort.store.bdb that return types with arguments of type ByteArray | |
---|---|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
BdbStorageEngine.entries()
|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
PartitionPrefixedBdbStorageEngine.entries(int partition)
|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
BdbStorageEngine.entries(int partition)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
BdbStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
StorageEngine<ByteArray,byte[],byte[]> |
BdbStorageConfiguration.getStore(StoreDefinition storeDef,
RoutingStrategy strategy)
|
ClosableIterator<ByteArray> |
BdbStorageEngine.keys()
|
ClosableIterator<ByteArray> |
PartitionPrefixedBdbStorageEngine.keys(int partition)
|
ClosableIterator<ByteArray> |
BdbStorageEngine.keys(int partition)
|
Methods in voldemort.store.bdb with parameters of type ByteArray | |
---|---|
boolean |
PartitionPrefixedBdbStorageEngine.delete(ByteArray key,
Version version)
|
boolean |
BdbStorageEngine.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
PartitionPrefixedBdbStorageEngine.get(ByteArray key,
byte[] transforms)
|
java.util.List<Versioned<byte[]>> |
BdbStorageEngine.get(ByteArray key,
byte[] transforms)
|
KeyLockHandle<byte[]> |
PartitionPrefixedBdbStorageEngine.getAndLock(ByteArray key)
|
KeyLockHandle<byte[]> |
BdbStorageEngine.getAndLock(ByteArray key)
|
java.util.List<Version> |
BdbStorageEngine.getVersions(ByteArray key)
|
void |
PartitionPrefixedBdbStorageEngine.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
void |
BdbStorageEngine.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
void |
PartitionPrefixedBdbStorageEngine.putAndUnlock(ByteArray key,
KeyLockHandle<byte[]> handle)
|
void |
BdbStorageEngine.putAndUnlock(ByteArray key,
KeyLockHandle<byte[]> handle)
|
Method parameters in voldemort.store.bdb with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
BdbStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
BdbStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
void |
BdbStorageConfiguration.removeStorageEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
Clean up the environment object for the given storage engine |
Uses of ByteArray in voldemort.store.compress |
---|
Methods in voldemort.store.compress that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
CompressingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Methods in voldemort.store.compress with parameters of type ByteArray | |
---|---|
boolean |
CompressingStore.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
CompressingStore.get(ByteArray key,
byte[] transforms)
|
java.util.List<Version> |
CompressingStore.getVersions(ByteArray key)
|
void |
CompressingStore.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
Method parameters in voldemort.store.compress with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
CompressingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
CompressingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Constructor parameters in voldemort.store.compress with type arguments of type ByteArray | |
---|---|
CompressingStore(Store<ByteArray,byte[],byte[]> innerStore,
CompressionStrategy keysCompressionStrategy,
CompressionStrategy valuesCompressionStrategy)
|
Uses of ByteArray in voldemort.store.configuration |
---|
Methods in voldemort.store.configuration that return types with arguments of type ByteArray | |
---|---|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
FileBackedCachingStorageEngine.entries()
|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
FileBackedCachingStorageEngine.entries(int partition)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
FileBackedCachingStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
StorageEngine<ByteArray,byte[],byte[]> |
FileBackedCachingStorageConfiguration.getStore(StoreDefinition storeDef,
RoutingStrategy strategy)
|
ClosableIterator<ByteArray> |
FileBackedCachingStorageEngine.keys()
|
ClosableIterator<ByteArray> |
FileBackedCachingStorageEngine.keys(int partition)
|
Methods in voldemort.store.configuration with parameters of type ByteArray | |
---|---|
boolean |
FileBackedCachingStorageEngine.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
FileBackedCachingStorageEngine.get(ByteArray key,
byte[] transforms)
|
java.util.List<Version> |
FileBackedCachingStorageEngine.getVersions(ByteArray key)
|
void |
FileBackedCachingStorageEngine.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
Method parameters in voldemort.store.configuration with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
FileBackedCachingStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
FileBackedCachingStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
void |
FileBackedCachingStorageConfiguration.removeStorageEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
|
Uses of ByteArray in voldemort.store.http |
---|
Methods in voldemort.store.http that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
HttpStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Methods in voldemort.store.http with parameters of type ByteArray | |
---|---|
boolean |
HttpStore.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
HttpStore.get(ByteArray key,
byte[] transforms)
|
java.util.List<Version> |
HttpStore.getVersions(ByteArray key)
|
void |
HttpStore.put(ByteArray key,
Versioned<byte[]> versioned,
byte[] transforms)
|
Method parameters in voldemort.store.http with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
HttpStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
HttpStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Uses of ByteArray in voldemort.store.invalidmetadata |
---|
Methods in voldemort.store.invalidmetadata that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
InvalidMetadataCheckingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Methods in voldemort.store.invalidmetadata with parameters of type ByteArray | |
---|---|
boolean |
InvalidMetadataCheckingStore.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
InvalidMetadataCheckingStore.get(ByteArray key,
byte[] transforms)
|
void |
InvalidMetadataCheckingStore.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
Method parameters in voldemort.store.invalidmetadata with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
InvalidMetadataCheckingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
InvalidMetadataCheckingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Constructor parameters in voldemort.store.invalidmetadata with type arguments of type ByteArray | |
---|---|
InvalidMetadataCheckingStore(int nodeId,
Store<ByteArray,byte[],byte[]> innerStore,
MetadataStore metadata)
Create a store which delegates its operations to its inner store and throws InvalidMetadataException if the partition for key
requested should not lie with this node. |
Uses of ByteArray in voldemort.store.memory |
---|
Methods in voldemort.store.memory that return types with arguments of type ByteArray | |
---|---|
StorageEngine<ByteArray,byte[],byte[]> |
InMemoryStorageConfiguration.getStore(StoreDefinition storeDef,
RoutingStrategy strategy)
|
StorageEngine<ByteArray,byte[],byte[]> |
CacheStorageConfiguration.getStore(StoreDefinition storeDef,
RoutingStrategy strategy)
|
Method parameters in voldemort.store.memory with type arguments of type ByteArray | |
---|---|
void |
InMemoryStorageConfiguration.removeStorageEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
|
void |
CacheStorageConfiguration.removeStorageEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
|
Uses of ByteArray in voldemort.store.metadata |
---|
Methods in voldemort.store.metadata that return types with arguments of type ByteArray | |
---|---|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
MetadataStore.entries()
|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
MetadataStore.entries(int partition)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
MetadataStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
ClosableIterator<ByteArray> |
MetadataStore.keys()
|
ClosableIterator<ByteArray> |
MetadataStore.keys(int partition)
|
Methods in voldemort.store.metadata with parameters of type ByteArray | |
---|---|
boolean |
MetadataStore.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
MetadataStore.get(ByteArray keyBytes,
byte[] transforms)
|
java.util.List<Version> |
MetadataStore.getVersions(ByteArray key)
|
void |
MetadataStore.put(ByteArray keyBytes,
Versioned<byte[]> valueBytes,
byte[] transforms)
A write through put to inner-store. |
Method parameters in voldemort.store.metadata with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
MetadataStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
MetadataStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Uses of ByteArray in voldemort.store.mysql |
---|
Methods in voldemort.store.mysql that return types with arguments of type ByteArray | |
---|---|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
MysqlStorageEngine.entries()
|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
MysqlStorageEngine.entries(int partition)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
MysqlStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
StorageEngine<ByteArray,byte[],byte[]> |
MysqlStorageConfiguration.getStore(StoreDefinition storeDef,
RoutingStrategy strategy)
|
ClosableIterator<ByteArray> |
MysqlStorageEngine.keys()
|
ClosableIterator<ByteArray> |
MysqlStorageEngine.keys(int partition)
|
Methods in voldemort.store.mysql with parameters of type ByteArray | |
---|---|
boolean |
MysqlStorageEngine.delete(ByteArray key,
Version maxVersion)
|
java.util.List<Versioned<byte[]>> |
MysqlStorageEngine.get(ByteArray key,
byte[] transforms)
|
java.util.List<Version> |
MysqlStorageEngine.getVersions(ByteArray key)
|
void |
MysqlStorageEngine.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
Method parameters in voldemort.store.mysql with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
MysqlStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
MysqlStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
void |
MysqlStorageConfiguration.removeStorageEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
|
Uses of ByteArray in voldemort.store.nonblockingstore |
---|
Methods in voldemort.store.nonblockingstore with parameters of type ByteArray | |
---|---|
void |
ThreadPoolBasedNonblockingStoreImpl.submitDeleteRequest(ByteArray key,
Version version,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
NonblockingStore.submitDeleteRequest(ByteArray key,
Version version,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
ThreadPoolBasedNonblockingStoreImpl.submitGetRequest(ByteArray key,
byte[] transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
NonblockingStore.submitGetRequest(ByteArray key,
byte[] transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
ThreadPoolBasedNonblockingStoreImpl.submitGetVersionsRequest(ByteArray key,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
NonblockingStore.submitGetVersionsRequest(ByteArray key,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
ThreadPoolBasedNonblockingStoreImpl.submitPutRequest(ByteArray key,
Versioned<byte[]> value,
byte[] transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
NonblockingStore.submitPutRequest(ByteArray key,
Versioned<byte[]> value,
byte[] transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
Method parameters in voldemort.store.nonblockingstore with type arguments of type ByteArray | |
---|---|
void |
ThreadPoolBasedNonblockingStoreImpl.submitGetAllRequest(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
ThreadPoolBasedNonblockingStoreImpl.submitGetAllRequest(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
NonblockingStore.submitGetAllRequest(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
NonblockingStore.submitGetAllRequest(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
Constructor parameters in voldemort.store.nonblockingstore with type arguments of type ByteArray | |
---|---|
ThreadPoolBasedNonblockingStoreImpl(java.util.concurrent.ExecutorService executor,
Store<ByteArray,byte[],byte[]> innerStore)
|
Uses of ByteArray in voldemort.store.quota |
---|
Methods in voldemort.store.quota that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
QuotaLimitingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Methods in voldemort.store.quota with parameters of type ByteArray | |
---|---|
boolean |
QuotaLimitingStore.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
QuotaLimitingStore.get(ByteArray key,
byte[] transforms)
|
void |
QuotaLimitingStore.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
Method parameters in voldemort.store.quota with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
QuotaLimitingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
QuotaLimitingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Constructor parameters in voldemort.store.quota with type arguments of type ByteArray | |
---|---|
QuotaLimitingStore(Store<ByteArray,byte[],byte[]> innerStore,
StoreStats storeStats,
QuotaLimitStats quotaStats,
FileBackedCachingStorageEngine quotaStore)
|
Uses of ByteArray in voldemort.store.readonly |
---|
Methods in voldemort.store.readonly that return types with arguments of type ByteArray | |
---|---|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
ReadOnlyStorageEngine.entries()
|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
ReadOnlyStorageEngine.entries(int partition)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
ReadOnlyStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
StorageEngine<ByteArray,byte[],byte[]> |
ReadOnlyStorageConfiguration.getStore(StoreDefinition storeDef,
RoutingStrategy strategy)
|
ClosableIterator<ByteArray> |
ReadOnlyStorageEngine.keys()
|
ClosableIterator<ByteArray> |
ReadOnlyStorageEngine.keys(int partition)
|
Methods in voldemort.store.readonly with parameters of type ByteArray | |
---|---|
boolean |
ReadOnlyStorageEngine.delete(ByteArray key,
Version version)
Not supported, throws UnsupportedOperationException if called |
java.util.List<Versioned<byte[]>> |
ReadOnlyStorageEngine.get(ByteArray key,
byte[] transforms)
|
java.util.List<Version> |
ReadOnlyStorageEngine.getVersions(ByteArray key)
|
void |
ReadOnlyStorageEngine.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
Not supported, throws UnsupportedOperationException if called |
Method parameters in voldemort.store.readonly with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
ReadOnlyStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
ReadOnlyStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
void |
ReadOnlyStorageConfiguration.removeStorageEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
Cleanup the Jmx bean registered previously |
Uses of ByteArray in voldemort.store.readonly.chunk |
---|
Methods in voldemort.store.readonly.chunk that return ByteArray | |
---|---|
ByteArray |
ChunkedFileSet.ROKeyIterator.next()
|
Methods in voldemort.store.readonly.chunk that return types with arguments of type ByteArray | |
---|---|
Pair<ByteArray,Versioned<byte[]>> |
ChunkedFileSet.ROEntriesIterator.next()
|
Uses of ByteArray in voldemort.store.rebalancing |
---|
Methods in voldemort.store.rebalancing that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
RedirectingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
RebootstrappingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
protected Store<ByteArray,byte[],byte[]> |
RedirectingStore.getRedirectingSocketStore(java.lang.String storeName,
int proxyNodeId)
Get the SocketStore to redirect to for the
proxy node, creating one if needed. |
Methods in voldemort.store.rebalancing with parameters of type ByteArray | |
---|---|
boolean |
RedirectingStore.delete(ByteArray key,
Version version)
TODO : Handle delete correctly. |
boolean |
RebootstrappingStore.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
RedirectingStore.get(ByteArray key,
byte[] transforms)
|
java.util.List<Versioned<byte[]>> |
RebootstrappingStore.get(ByteArray key,
byte[] transforms)
|
java.util.List<Version> |
RedirectingStore.getVersions(ByteArray key)
|
java.util.List<Version> |
RebootstrappingStore.getVersions(ByteArray key)
|
void |
RedirectingStore.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
void |
RebootstrappingStore.put(ByteArray key,
Versioned<byte[]> versioned,
byte[] transforms)
|
Method parameters in voldemort.store.rebalancing with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
RedirectingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
RedirectingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
RebootstrappingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
RebootstrappingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Constructor parameters in voldemort.store.rebalancing with type arguments of type ByteArray | |
---|---|
RedirectingStore(Store<ByteArray,byte[],byte[]> innerStore,
MetadataStore metadata,
StoreRepository storeRepository,
FailureDetector detector,
SocketStoreFactory storeFactory,
java.util.concurrent.ExecutorService proxyPutWorkerPool,
ProxyPutStats proxyPutStats)
|
Uses of ByteArray in voldemort.store.retention |
---|
Methods in voldemort.store.retention that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
RetentionEnforcingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Methods in voldemort.store.retention with parameters of type ByteArray | |
---|---|
java.util.List<Versioned<byte[]>> |
RetentionEnforcingStore.get(ByteArray key,
byte[] transforms)
|
Method parameters in voldemort.store.retention with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
RetentionEnforcingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
RetentionEnforcingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Constructor parameters in voldemort.store.retention with type arguments of type ByteArray | |
---|---|
RetentionEnforcingStore(Store<ByteArray,byte[],byte[]> innerStore,
StoreDefinition storeDef,
boolean deleteExpiredEntries,
Time time)
|
Uses of ByteArray in voldemort.store.routed |
---|
Fields in voldemort.store.routed with type parameters of type ByteArray | |
---|---|
protected java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> |
RoutedStore.innerStores
|
protected ReadRepairer<ByteArray,byte[]> |
RoutedStore.readRepairer
|
protected java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> |
PipelineRoutedStore.slopStores
|
Methods in voldemort.store.routed that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
PipelineRoutedStore.getAll(CompositeVoldemortRequest<ByteArray,byte[]> request)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
PipelineRoutedStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
ThreadPoolRoutedStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
Deprecated. |
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
PipelineRoutedStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
long getAllOpTimeoutInMs)
|
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> |
RoutedStore.getInnerStores()
|
java.util.Map<ByteArray,java.util.List<Node>> |
GetAllPipelineData.getKeyToExtraNodesMap()
|
java.util.Map<ByteArray,java.util.HashSet<java.lang.Integer>> |
GetAllPipelineData.getKeyToZoneResponse()
|
java.util.Map<Node,java.util.List<ByteArray>> |
GetAllPipelineData.getNodeToKeysMap()
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
GetAllPipelineData.getResult()
|
java.util.Map<ByteArray,byte[]> |
GetAllPipelineData.getTransforms()
|
Methods in voldemort.store.routed with parameters of type ByteArray | |
---|---|
boolean |
PipelineRoutedStore.delete(ByteArray key,
Version version)
|
boolean |
ThreadPoolRoutedStore.delete(ByteArray key,
Version version)
Deprecated. |
protected boolean |
PipelineRoutedStore.delete(ByteArray key,
Version version,
long deleteOpTimeout)
|
java.util.List<Versioned<byte[]>> |
PipelineRoutedStore.get(ByteArray key,
byte[] transforms)
|
java.util.List<Versioned<byte[]>> |
ThreadPoolRoutedStore.get(ByteArray key,
byte[] transforms)
Deprecated. |
java.util.List<Versioned<byte[]>> |
PipelineRoutedStore.get(ByteArray key,
byte[] transforms,
long getOpTimeout)
|
org.apache.commons.lang.mutable.MutableInt |
GetAllPipelineData.getSuccessCount(ByteArray key)
|
java.util.List<Version> |
PipelineRoutedStore.getVersions(ByteArray key)
|
java.util.List<Version> |
ThreadPoolRoutedStore.getVersions(ByteArray key)
Deprecated. |
void |
PipelineRoutedStore.put(ByteArray key,
Versioned<byte[]> versioned,
byte[] transforms)
|
void |
ThreadPoolRoutedStore.put(ByteArray key,
Versioned<byte[]> versioned,
byte[] transforms)
Deprecated. |
void |
PipelineRoutedStore.put(ByteArray key,
Versioned<byte[]> versioned,
byte[] transforms,
long putOpTimeoutInMs)
|
Method parameters in voldemort.store.routed with type arguments of type ByteArray | |
---|---|
RoutedStore |
RoutedStoreFactory.create(Cluster cluster,
StoreDefinition storeDefinition,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> nodeStores,
FailureDetector failureDetector,
RoutedStoreConfig routedStoreConfig)
|
RoutedStore |
RoutedStoreFactory.create(Cluster cluster,
StoreDefinition storeDefinition,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> nodeStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> slopStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingSlopStores,
FailureDetector failureDetector,
RoutedStoreConfig routedStoreConfig)
|
RoutedStore |
RoutedStoreFactory.create(Cluster cluster,
StoreDefinition storeDefinition,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> nodeStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> slopStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingSlopStores,
FailureDetector failureDetector,
RoutedStoreConfig routedStoreConfig)
|
boolean |
PipelineRoutedStore.delete(CompositeVoldemortRequest<ByteArray,byte[]> request)
|
java.util.List<Versioned<byte[]>> |
PipelineRoutedStore.get(CompositeVoldemortRequest<ByteArray,byte[]> request)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
PipelineRoutedStore.getAll(CompositeVoldemortRequest<ByteArray,byte[]> request)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
PipelineRoutedStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
PipelineRoutedStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
ThreadPoolRoutedStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
Deprecated. |
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
ThreadPoolRoutedStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
Deprecated. |
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
PipelineRoutedStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
long getAllOpTimeoutInMs)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
PipelineRoutedStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
long getAllOpTimeoutInMs)
|
void |
PipelineRoutedStore.put(CompositeVoldemortRequest<ByteArray,byte[]> request)
|
void |
GetAllPipelineData.setKeyToExtraNodesMap(java.util.Map<ByteArray,java.util.List<Node>> keyToExtraNodesMap)
|
void |
GetAllPipelineData.setNodeToKeysMap(java.util.Map<Node,java.util.List<ByteArray>> nodeToKeysMap)
|
void |
GetAllPipelineData.setTransforms(java.util.Map<ByteArray,byte[]> transforms)
|
NonblockingStore |
RoutedStoreFactory.toNonblockingStore(Store<ByteArray,byte[],byte[]> store)
|
Constructor parameters in voldemort.store.routed with type arguments of type ByteArray | |
---|---|
PipelineRoutedStore(java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> innerStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> slopStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingSlopStores,
Cluster cluster,
StoreDefinition storeDef,
FailureDetector failureDetector,
boolean repairReads,
TimeoutConfig timeoutConfig,
int clientZoneId,
boolean isJmxEnabled,
java.lang.String identifierString,
ZoneAffinity zoneAffinity)
Create a PipelineRoutedStore |
|
PipelineRoutedStore(java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> innerStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> slopStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingSlopStores,
Cluster cluster,
StoreDefinition storeDef,
FailureDetector failureDetector,
boolean repairReads,
TimeoutConfig timeoutConfig,
int clientZoneId,
boolean isJmxEnabled,
java.lang.String identifierString,
ZoneAffinity zoneAffinity)
Create a PipelineRoutedStore |
|
RoutedStore(java.lang.String name,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> innerStores,
Cluster cluster,
StoreDefinition storeDef,
boolean repairReads,
TimeoutConfig timeoutConfig,
FailureDetector failureDetector,
Time time)
|
|
ThreadPoolRoutedStore(java.lang.String name,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> innerStores,
Cluster cluster,
StoreDefinition storeDef,
boolean repairReads,
java.util.concurrent.ExecutorService threadPool,
TimeoutConfig timeoutConfig,
FailureDetector failureDetector,
Time time)
Deprecated. Create a RoutedStoreClient |
|
ThreadPoolRoutedStore(java.lang.String name,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> innerStores,
Cluster cluster,
StoreDefinition storeDef,
int numberOfThreads,
boolean repairReads,
TimeoutConfig timeoutConfig,
FailureDetector failureDetector)
Deprecated. Create a RoutedStoreClient |
Uses of ByteArray in voldemort.store.routed.action |
---|
Methods in voldemort.store.routed.action that return types with arguments of type ByteArray | |
---|---|
Response<ByteArray,java.lang.Object> |
AsyncPutSynchronizer.responseQueuePoll(long timeout,
java.util.concurrent.TimeUnit timeUnit)
poll the response queue for response |
Methods in voldemort.store.routed.action with parameters of type ByteArray | |
---|---|
protected java.util.List<Node> |
AbstractConfigureNodes.getNodes(ByteArray key)
|
protected java.util.List<Node> |
ConfigureNodesLocalZoneOnly.getNodes(ByteArray key)
|
java.util.List<Node> |
ConfigureNodesDefault.getNodes(ByteArray key)
|
java.util.List<Node> |
ConfigureNodesLocalHost.getNodes(ByteArray key)
|
java.util.List<Node> |
ConfigureNodesLocalHostByZone.getNodes(ByteArray key,
Pipeline.Operation op)
|
java.util.List<Node> |
ConfigureNodesByZone.getNodes(ByteArray key,
Pipeline.Operation op)
|
protected void |
AbstractReadRepair.insertNodeValue(Node node,
ByteArray key,
java.util.List<Versioned<byte[]>> value)
|
Method parameters in voldemort.store.routed.action with type arguments of type ByteArray | |
---|---|
boolean |
AsyncPutSynchronizer.tryDelegateResponseHandling(Response<ByteArray,java.lang.Object> response)
try to delegate the master to handle the response |
Constructors in voldemort.store.routed.action with parameters of type ByteArray | |
---|---|
AbstractHintedHandoffAction(PD pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
HintedHandoff hintedHandoff)
|
|
ConfigureNodes(PD pipelineData,
Pipeline.Event completeEvent,
FailureDetector failureDetector,
int required,
RoutingStrategy routingStrategy,
ByteArray key,
Zone clientZone)
|
|
ConfigureNodesByZone(PD pipelineData,
Pipeline.Event completeEvent,
FailureDetector failureDetector,
int required,
RoutingStrategy routingStrategy,
ByteArray key,
Zone clientZone)
|
|
ConfigureNodesDefault(PD pipelineData,
Pipeline.Event completeEvent,
FailureDetector failureDetector,
int required,
RoutingStrategy routingStrategy,
ByteArray key)
|
|
ConfigureNodesLocalHost(PD pipelineData,
Pipeline.Event completeEvent,
FailureDetector failureDetector,
int required,
RoutingStrategy routingStrategy,
ByteArray key)
|
|
ConfigureNodesLocalHostByZone(PD pipelineData,
Pipeline.Event completeEvent,
FailureDetector failureDetector,
int required,
RoutingStrategy routingStrategy,
ByteArray key,
Zone clientZone)
|
|
ConfigureNodesLocalZoneOnly(PD pipelineData,
Pipeline.Event completeEvent,
FailureDetector failureDetector,
int required,
RoutingStrategy routingStrategy,
ByteArray key,
Zone clientZone)
|
|
PerformDeleteHintedHandoff(BasicPipelineData<java.lang.Boolean> pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
Version version,
HintedHandoff hintedHandoff)
|
|
PerformParallelDeleteRequests(PD pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
FailureDetector failureDetector,
int preferred,
int required,
long timeoutMs,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
HintedHandoff hintedHandoff,
PerformDeleteHintedHandoff hintedHandoffAction,
Version version)
|
|
PerformParallelPutRequests(PutPipelineData pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
byte[] transforms,
FailureDetector failureDetector,
int preferred,
int required,
long timeoutMs,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
HintedHandoff hintedHandoff)
|
|
PerformParallelRequests(PD pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
byte[] transforms,
FailureDetector failureDetector,
int preferred,
int required,
long timeoutMs,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
Pipeline.Event insufficientSuccessesEvent,
Pipeline.Event insufficientZonesEvent)
|
|
PerformPutHintedHandoff(PutPipelineData pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
Versioned<byte[]> versioned,
byte[] transforms,
HintedHandoff hintedHandoff,
Time time)
|
|
PerformSerialPutRequests(PutPipelineData pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
byte[] transforms,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
int required,
Versioned<byte[]> versioned,
Time time,
Pipeline.Event masterDeterminedEvent)
|
|
PerformSerialRequests(PD pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
int preferred,
int required,
StoreRequest<V> storeRequest,
Pipeline.Event insufficientSuccessesEvent)
|
|
PerformZoneSerialRequests(PD pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
StoreRequest<V> storeRequest)
|
Constructor parameters in voldemort.store.routed.action with type arguments of type ByteArray | |
---|---|
AbstractReadRepair(PD pipelineData,
Pipeline.Event completeEvent,
int preferred,
long timeoutMs,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
ReadRepairer<ByteArray,byte[]> readRepairer)
|
|
GetAllConfigureNodes(GetAllPipelineData pipelineData,
Pipeline.Event completeEvent,
FailureDetector failureDetector,
int preferred,
int required,
RoutingStrategy routingStrategy,
java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
Zone clientZone,
ZoneAffinity zoneAffinity)
|
|
GetAllConfigureNodes(GetAllPipelineData pipelineData,
Pipeline.Event completeEvent,
FailureDetector failureDetector,
int preferred,
int required,
RoutingStrategy routingStrategy,
java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
Zone clientZone,
ZoneAffinity zoneAffinity)
|
|
GetAllReadRepair(GetAllPipelineData pipelineData,
Pipeline.Event completeEvent,
int preferred,
long timeoutMs,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
ReadRepairer<ByteArray,byte[]> readRepairer)
|
|
PerformSerialGetAllRequests(GetAllPipelineData pipelineData,
Pipeline.Event completeEvent,
java.lang.Iterable<ByteArray> keys,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
int preferred,
int required,
boolean allowPartial)
|
|
PerformSerialGetAllRequests(GetAllPipelineData pipelineData,
Pipeline.Event completeEvent,
java.lang.Iterable<ByteArray> keys,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
int preferred,
int required,
boolean allowPartial)
|
|
PerformSerialPutRequests(PutPipelineData pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
byte[] transforms,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
int required,
Versioned<byte[]> versioned,
Time time,
Pipeline.Event masterDeterminedEvent)
|
|
PerformSerialRequests(PD pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
int preferred,
int required,
StoreRequest<V> storeRequest,
Pipeline.Event insufficientSuccessesEvent)
|
|
PerformZoneSerialRequests(PD pipelineData,
Pipeline.Event completeEvent,
ByteArray key,
FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,byte[],byte[]>> stores,
StoreRequest<V> storeRequest)
|
|
ReadRepair(PD pipelineData,
Pipeline.Event completeEvent,
int preferred,
long timeoutMs,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingStores,
ReadRepairer<ByteArray,byte[]> readRepairer)
|
Uses of ByteArray in voldemort.store.serialized |
---|
Method parameters in voldemort.store.serialized with type arguments of type ByteArray | ||
---|---|---|
static
|
SerializingStorageEngine.wrap(StorageEngine<ByteArray,byte[],byte[]> s,
Serializer<K1> k,
Serializer<V1> v,
Serializer<T1> t)
|
|
static
|
SerializingStore.wrap(Store<ByteArray,byte[],byte[]> s,
Serializer<K1> k,
Serializer<V1> v,
Serializer<T1> t)
|
Constructor parameters in voldemort.store.serialized with type arguments of type ByteArray | |
---|---|
SerializingStorageEngine(StorageEngine<ByteArray,byte[],byte[]> innerStorageEngine,
Serializer<K> keySerializer,
Serializer<V> valueSerializer,
Serializer<T> transformsSerializer)
|
|
SerializingStore(Store<ByteArray,byte[],byte[]> store,
Serializer<K> keySerializer,
Serializer<V> valueSerializer,
Serializer<T> transformsSerializer)
|
Uses of ByteArray in voldemort.store.slop |
---|
Methods in voldemort.store.slop that return ByteArray | |
---|---|
ByteArray |
Slop.getKey()
|
ByteArray |
Slop.makeKey()
|
Methods in voldemort.store.slop that return types with arguments of type ByteArray | |
---|---|
StorageEngine<ByteArray,Slop,byte[]> |
SlopStorageEngine.asSlopStore()
|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
SlopStorageEngine.entries()
|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
SlopStorageEngine.entries(int partition)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
SlopStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
ClosableIterator<ByteArray> |
SlopStorageEngine.keys()
|
ClosableIterator<ByteArray> |
SlopStorageEngine.keys(int partition)
|
Methods in voldemort.store.slop with parameters of type ByteArray | |
---|---|
boolean |
SlopStorageEngine.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
SlopStorageEngine.get(ByteArray key,
byte[] transforms)
|
java.util.List<Version> |
SlopStorageEngine.getVersions(ByteArray key)
|
void |
SlopStorageEngine.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
Method parameters in voldemort.store.slop with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
SlopStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
SlopStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Constructors in voldemort.store.slop with parameters of type ByteArray | |
---|---|
Slop(java.lang.String storeName,
Slop.Operation operation,
ByteArray key,
byte[] value,
byte[] transforms,
int nodeId,
java.util.Date arrived)
|
Constructor parameters in voldemort.store.slop with type arguments of type ByteArray | |
---|---|
HintedHandoff(FailureDetector failureDetector,
java.util.Map<java.lang.Integer,Store<ByteArray,Slop,byte[]>> slopStores,
java.util.Map<java.lang.Integer,NonblockingStore> nonblockingSlopStores,
HintedHandoffStrategy handoffStrategy,
java.util.List<Node> failedNodes,
long timeoutMs)
Create a Hinted Handoff object |
|
SlopStorageEngine(StorageEngine<ByteArray,byte[],byte[]> slopEngine,
Cluster cluster)
|
Uses of ByteArray in voldemort.store.socket |
---|
Methods in voldemort.store.socket that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
SocketStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Methods in voldemort.store.socket with parameters of type ByteArray | |
---|---|
boolean |
SocketStore.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
SocketStore.get(ByteArray key,
byte[] transforms)
|
java.util.List<Version> |
SocketStore.getVersions(ByteArray key)
|
void |
SocketStore.put(ByteArray key,
Versioned<byte[]> versioned,
byte[] transforms)
|
void |
SocketStore.submitDeleteRequest(ByteArray key,
Version version,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
SocketStore.submitGetRequest(ByteArray key,
byte[] transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
SocketStore.submitGetVersionsRequest(ByteArray key,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
SocketStore.submitPutRequest(ByteArray key,
Versioned<byte[]> value,
byte[] transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
Method parameters in voldemort.store.socket with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
SocketStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
SocketStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
void |
SocketStore.submitGetAllRequest(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
void |
SocketStore.submitGetAllRequest(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms,
NonblockingStoreCallback callback,
long timeoutMs)
|
Uses of ByteArray in voldemort.store.socket.clientrequest |
---|
Methods in voldemort.store.socket.clientrequest that return types with arguments of type ByteArray | |
---|---|
protected java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
GetAllClientRequest.parseResponseInternal(java.io.DataInputStream inputStream)
|
Constructors in voldemort.store.socket.clientrequest with parameters of type ByteArray | |
---|---|
DeleteClientRequest(java.lang.String storeName,
RequestFormat requestFormat,
RequestRoutingType requestRoutingType,
ByteArray key,
Version version)
|
|
GetClientRequest(java.lang.String storeName,
RequestFormat requestFormat,
RequestRoutingType requestRoutingType,
ByteArray key,
byte[] transforms)
|
|
GetVersionsClientRequest(java.lang.String storeName,
RequestFormat requestFormat,
RequestRoutingType requestRoutingType,
ByteArray key)
|
|
PutClientRequest(java.lang.String storeName,
RequestFormat requestFormat,
RequestRoutingType requestRoutingType,
ByteArray key,
Versioned<byte[]> versioned,
byte[] transforms)
|
Constructor parameters in voldemort.store.socket.clientrequest with type arguments of type ByteArray | |
---|---|
GetAllClientRequest(java.lang.String storeName,
RequestFormat requestFormat,
RequestRoutingType requestRoutingType,
java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
|
GetAllClientRequest(java.lang.String storeName,
RequestFormat requestFormat,
RequestRoutingType requestRoutingType,
java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Uses of ByteArray in voldemort.store.stats |
---|
Methods in voldemort.store.stats that return types with arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
StatTrackingStore.getAll(CompositeVoldemortRequest<ByteArray,byte[]> request)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
StatTrackingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
Methods in voldemort.store.stats with parameters of type ByteArray | |
---|---|
boolean |
StatTrackingStore.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
StatTrackingStore.get(ByteArray key,
byte[] transforms)
|
java.util.List<Version> |
StatTrackingStore.getVersions(ByteArray key)
|
void |
StatTrackingStore.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
Method parameters in voldemort.store.stats with type arguments of type ByteArray | |
---|---|
boolean |
StatTrackingStore.delete(CompositeVoldemortRequest<ByteArray,byte[]> request)
|
java.util.List<Versioned<byte[]>> |
StatTrackingStore.get(CompositeVoldemortRequest<ByteArray,byte[]> request)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
StatTrackingStore.getAll(CompositeVoldemortRequest<ByteArray,byte[]> request)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
StatTrackingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
StatTrackingStore.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
void |
StatTrackingStore.put(CompositeVoldemortRequest<ByteArray,byte[]> request)
|
Constructor parameters in voldemort.store.stats with type arguments of type ByteArray | |
---|---|
StatTrackingStore(Store<ByteArray,byte[],byte[]> innerStore,
StoreStats parentStats)
|
Uses of ByteArray in voldemort.store.views |
---|
Methods in voldemort.store.views that return types with arguments of type ByteArray | |
---|---|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
ViewStorageEngine.entries()
|
ClosableIterator<Pair<ByteArray,Versioned<byte[]>>> |
ViewStorageEngine.entries(int partition)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
ViewStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
StorageEngine<ByteArray,byte[],byte[]> |
ViewStorageConfiguration.getStore(StoreDefinition storeDef,
RoutingStrategy strategy)
|
ClosableIterator<ByteArray> |
ViewStorageEngine.keys()
|
ClosableIterator<ByteArray> |
ViewStorageEngine.keys(int partition)
|
Methods in voldemort.store.views with parameters of type ByteArray | |
---|---|
boolean |
ViewStorageEngine.delete(ByteArray key,
Version version)
|
java.util.List<Versioned<byte[]>> |
ViewStorageEngine.get(ByteArray key,
byte[] transforms)
|
java.util.List<Version> |
ViewStorageEngine.getVersions(ByteArray key)
|
void |
ViewStorageEngine.put(ByteArray key,
Versioned<byte[]> value,
byte[] transforms)
|
Method parameters in voldemort.store.views with type arguments of type ByteArray | |
---|---|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
ViewStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
java.util.Map<ByteArray,java.util.List<Versioned<byte[]>>> |
ViewStorageEngine.getAll(java.lang.Iterable<ByteArray> keys,
java.util.Map<ByteArray,byte[]> transforms)
|
void |
ViewStorageConfiguration.removeStorageEngine(StorageEngine<ByteArray,byte[],byte[]> engine)
|
Constructor parameters in voldemort.store.views with type arguments of type ByteArray | |
---|---|
ViewStorageEngine(java.lang.String name,
StorageEngine<ByteArray,byte[],byte[]> target,
Serializer<?> valSerializer,
Serializer<?> transformSerializer,
Serializer<?> targetKeySerializer,
Serializer<?> targetValSerializer,
CompressionStrategy valueCompressionStrategy,
View<?,?,?,?> valueTrans)
|
Uses of ByteArray in voldemort.tools |
---|
Methods in voldemort.tools that return types with arguments of type ByteArray | |
---|---|
static Pair<ByteArray,Versioned<byte[]>> |
ImportTextDumpToBDB.lineToEntry(java.lang.String line)
|
Method parameters in voldemort.tools with type arguments of type ByteArray | |
---|---|
static java.lang.String |
ExportBDBToTextDump.makeLine(Pair<ByteArray,Versioned<byte[]>> pair)
|
Uses of ByteArray in voldemort.utils |
---|
Fields in voldemort.utils declared as ByteArray | |
---|---|
static ByteArray |
ByteArray.EMPTY
|
Methods in voldemort.utils that return ByteArray | |
---|---|
ByteArray |
ConsistencyCheck.KeyFetchTracker.nextFinished()
Get a key that are completed in fetching |
Methods in voldemort.utils with parameters of type ByteArray | |
---|---|
static java.lang.String |
ConsistencyCheck.keyVersionToString(ByteArray key,
java.util.Map<ConsistencyCheck.Value,java.util.Set<ConsistencyCheck.ClusterNode>> versionMap,
java.lang.String storeName,
java.lang.Integer partitionId)
Convert a key-version-nodeSet information to string |
void |
ConsistencyCheck.KeyFetchTracker.recordFetch(ConsistencyCheck.ClusterNode clusterNode,
ByteArray key)
Record a fetched result |
void |
ConsistencyCheck.recordFetch(ConsistencyCheck.ClusterNode clusterNode,
ByteArray key,
Versioned<byte[]> versioned)
|
Method parameters in voldemort.utils with type arguments of type ByteArray | |
---|---|
static void |
ConsistencyCheck.cleanIneligibleKeys(java.util.Map<ByteArray,java.util.Map<ConsistencyCheck.Value,java.util.Set<ConsistencyCheck.ClusterNode>>> keyVersionNodeSetMap,
int requiredWrite)
Determine if a key version is invalid by comparing the version's existance and required writes configuration |
void |
ConsistencyCheck.Reporter.processInconsistentKeys(java.lang.String storeName,
java.lang.Integer partitionId,
java.util.Map<ByteArray,java.util.Map<ConsistencyCheck.Value,java.util.Set<ConsistencyCheck.ClusterNode>>> keyVersionNodeSetMap)
|
static java.lang.Iterable<java.lang.String> |
ByteArray.toHexStrings(java.lang.Iterable<ByteArray> arrays)
Translate the each ByteArray in an iterable into a hexidecimal string |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |