|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
RequestHandlerStoreClientFactory implementationsPipeline receiving an
Pipeline.Event.Cluster object.
AdminClientRequestHandlerMetadataStore.VoldemortState MetadataStore.VoldemortState.NORMAL_SERVER).
MetadataStore.VoldemortState MetadataStore.VoldemortState.NORMAL_SERVER).
MetadataStore.VoldemortState MetadataStore.VoldemortState.NORMAL_SERVER).
Double list
Long list
ClientRequest logic.StoreClientFactory which caches requests to
getStoreClientMetadataStore.VoldemortState MetadataStore.VoldemortState.NORMAL_SERVER).
ClientRequestExecutorPool to execute
requests for the client.ClientRequestExecutor keyed off the
SocketDestination.ClientRequestExecutor once all the processing
(normal or abnormal) has occurred on the ClientRequest object.
MetadataStoreSocketDestination.
Object.equals(Object), or "deeply equal" if both are arrays.
StoreClient implementation
you get back from a StoreClientFactoryRebalanceUtils.vacateZone(Cluster, int), takes the
current store definitions in the cluster and creates store definitions
with the specified zone effectively dropped.
ClassLoader.getResource(String) internally to find the class
file and then dump the bytes[]
ZenStoreClient is created as opposed to a
DefaultStoreClient
true = DefaultStoreClient and false = ZenStoreClient
VoldemortConfig).
ClientConfig).
RequestFormat instance's
writeXxx method.
getAll, except
that the transforms are applied on the value associated with each key
before returning the results
StorageEngine.putAndUnlock(Object, KeyLockHandle) or
StorageEngine.releaseLock(KeyLockHandle) is called with the same
lock handle.
VoldemortConfig.getFailureDetectorBannagePeriod() instead
ClientConfig.getFailureDetectorBannagePeriod() instead
SocketStore to redirect to for the
proxy node, creating one if needed.
MetadataStore.VoldemortState from a
remote node.
AdminClient.ReadOnlySpecificOperations.getROMaxVersion(int, List) where-in
we find the max versions on each machine and then return the max of
all of them
ReadOnlyStorageFormat
for a list of stores
StoreClient for the given store.
StoreClient for the given store.
ClientConfig.setTimeoutConfig(TimeoutConfig)
Versioned as determined by
PerformSerialPutRequests.
Gossiper object, which implements Runnable
allowing it to be run as a thread or be submitted to an Executor.
RoutingStrategy for hints.HintedHandoffStrategy for a given
HintedHandoffStrategyType.InvalidMetadataException if a client requests
a partition which is not or should not be available at this node.InvalidMetadataException if the partition for key
requested should not lie with this node.
true if ClientRequest.complete() was called.
ClientRequestExecutor's received thus far is inclusive of the
entire response.
true if ClientRequestExecutor timed out.
JsonReaderStoreClient with lazy initialization.AsyncRecoveryFailureDetector class.
Store interface but instead of blocking
for the request to complete, it simply submits it for later processing and
returns immediately.NonblockingStore API.NonblockingStore API.Pair.create(Object, Object) instead of
this where possible.
Action is run.Pipeline as it moves from action to action.VersionedPutPruneJob
VersionedPutPruneJob
#put(Object, Object), except
that the given transforms are applied on the value before writing it to
the store
StorageEngine.getAndLock(Object) call, and update the key with
the set of values provided in the handle, also releasing the lock held on
the key.
DefaultStoreClient for server side routingDelegatingStoreRebootstrappingStore.
AbstractStorageEngine.getAndLock(Object) call.
RepairJob
Store.
RequestFormatTypeRequestFormatType.resolveConflict([null, null]) == null
if t != null, then
resolveConflict([null, t]) == resolveConflict([t, null]) == t
RoutingStrategy for a given
RoutingStrategyType.MetadataStore.GOSSIP_KEYS with that peer
and then sleep for a specified interval.
HintedHandoff.sendHintSerial(voldemort.cluster.Node, voldemort.versioning.Version, Slop)
, but doesn't block the pipeline.
ClientConfig.setConnectionTimeout(int, java.util.concurrent.TimeUnit)
to use in AdminService
Property :"admin.client.connection.timeout.sec"
Default :60
ClientConfig.setSocketBufferSize(int) to use for network
operations during admin operations
Property :"admin.streams.buffer.size"
Default :10MB
ClientConfig.setSocketTimeout(int, java.util.concurrent.TimeUnit)
to use in AdminService
Property :"admin.client.socket.timeout.sec"
Default :24 * 60 * 60
AbstractStoreClientFactory will
internally reuse StoreClient instances for each store.
ClientConfig.setConnectionTimeout(int, java.util.concurrent.TimeUnit)
Property :"client.connection.timeout.ms"
Default :500
ClientConfig.setMaxConnectionsPerNode(int)
Property :"client.max.connections.per.node"
Default :50
ClientConfig.setMaxQueuedRequests(int)
Property :
Default :
ClientConfig.setMaxThreads(int)
Property :"client.max.threads"
Default :500
VoldemortConfig.setFailureDetectorBannagePeriod(long) instead
ClientConfig.setRoutingTimeout(int, java.util.concurrent.TimeUnit)
Property :"client.routing.timeout.ms"
Default :15000
ClientConfig.setSelectors(int)
Property :"client.selectors"
Default :4
ClientConfig.setThreadIdleTime(long, java.util.concurrent.TimeUnit)
Property :"client.thread.idle.ms"
Default :100000
HttpService is enabled
Property :"http.enable"
Default :true
InvalidMetadataCheckingStore will reject traffic that
does not belong to this server with a InvalidMetadataException
Property :"enable.metadata.checking"
Default :true
VAdminProto.VoldemortFilter.
VersionedPutPruneJob will be enabled
Property :"enable.prunejob"
Default :true
RepairJob will be enabled
Property :"enable.repair"
Default :true
RestService is enabled
Property :"rest.enable"
Default :false
SlopPurgeJob be enabled
Property :"enable.slop.purge.job"
Default :true
StreamingSlopPusherJob or
BlockingSlopPusherJob should be enabled to asynchronous push
slops to failed servers
Property :"slop.pusher.enable"
Default :true
StatTrackingStore will be enabled to account
performance statistics
Property :"enable.stat.tracking"
Default :true
LoggingStore will be enable to ouput more detailed
trace debugging if needed
Property :"enable.verbose.logging"
Default :true
ClientConfig.setFailureDetectorAsyncRecoveryInterval(long)
Property :"failuredetector.asyncrecovery.interval"
Default :FailureDetectorConfig.DEFAULT_ASYNC_RECOVERY_INTERVAL
ClientConfig.setFailureDetectorBannagePeriod(long)
Property :"failuredetector.bannage.period"
Default :FailureDetectorConfig.DEFAULT_BANNAGE_PERIOD
ClientConfig.setFailureDetectorCatastrophicErrorTypes(List)
Property :"failuredetector.catastrophic.error.types"
Default :FailureDetectorConfig.DEFAULT_CATASTROPHIC_ERROR_TYPES
ClientConfig.setFailureDetectorImplementation(String)
Property :"failuredetector.implementation"
Default :FailureDetectorConfig.DEFAULT_IMPLEMENTATION_CLASS_NAME
ClientConfig.setFailureDetectorRequestLengthThreshold(long)
Property :"failuredetector.request.length.threshold"
Default :same as socket timeout
ClientConfig.setFailureDetectorThreshold(int)
Property :"failuredetector.threshold"
Default :FailureDetectorConfig.DEFAULT_THRESHOLD
ClientConfig.setFailureDetectorThresholdCountMinimum(int)
Property :"failuredetector.threshold.countminimum"
Default :FailureDetectorConfig.DEFAULT_THRESHOLD_COUNT_MINIMUM
ClientConfig.setFailureDetectorThresholdInterval(long)
Property :"failuredetector.threshold.interval"
Default :FailureDetectorConfig.DEFAULT_THRESHOLD_INTERVAL
AsyncOperation, when terminating the job
Property :"service.interruptible"
Default :true
Node as determined by
PerformSerialPutRequests.
NioSocketService's accept backlog
queue.
ClientConfig.setFailureDetectorBannagePeriod(long) instead
ReadOnlyStorageEngine
Property :"readonly.backups"
Default :1
ClientConfig.setRequestFormatType(RequestFormatType)
Property :"request.format"
Default :"vp1"
DataCleanupJob, after server starts
up.
DataCleanupJob will start
Property :"retention.cleanup.first.start.hour"
Default :0
DataCleanupJob will be pinned to the same time each
run interval.
DataCleanupJob
Property :
Default :
SchedulerService threads to create that run all the
background async jobs
Property :"client.max.queued.requests"
Default :1000
StreamingSlopPusherJob reads the
'slop' store and drains it off to another server
Property :"slop.read.byte.per.sec"
Default :10MB
StreamingSlopPusherJob will send
slop writes over the wire
Property :"slop.write.byte.per.sec"
Default :10MB
ClientConfig.setSocketBufferSize(int)
Property :"socket.buffer.size"
Default :64kb
ClientConfig.setSocketKeepAlive(boolean)
Property :"socket.keepalive"
Default :false
ClientConfig.setSocketTimeout(int, java.util.concurrent.TimeUnit)
Property :"socket.timeout.ms"
Default :5000
StorageEngine types to
enable on the server
Property :"storage.configs"
Default : BdbStorageConfiguration
MysqlStorageConfiguration InMemoryStorageConfiguration
CacheStorageConfiguration ReadOnlyStorageConfiguration
StorageEngine.isPartitionScanSupported()
Property :"use.partition.scan.for.rebalance"
Default :true
Versioned instance that was incremented before
attempting to put on the remote Voldemort node.
RequestFormatType.SocketStore instances.Gossiper.run() is invoked.
RebalanceTaskInfo instance on
the rebalance client side.StoreClient instances to
interact with individual stores.Store API.StreamRequestHandler.StreamRequestHandlerState.COMPLETE.NonblockingStore.
Double list
Long list
ClientRequestExecutor after it has timed out.
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.
MetadataStore.CLUSTER_KEY on a
remote node.
AdminClientAdminClientRequestFormat for a low-overhead custom
binary protocolHashMap as a Write through cache StoreClient implementation
you get back from a StoreClientFactory
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||