|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
RequestHandler
StoreClientFactory
implementationsPipeline
receiving an
Pipeline.Event
.Cluster
object.
AdminClient
RequestHandler
MetadataStore.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
getStoreClient
MetadataStore.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.
MetadataStore
SocketDestination
.
Object.equals(Object)
, or "deeply equal" if both are arrays.
StoreClient
implementation
you get back from a StoreClientFactory
RebalanceUtils.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.
JsonReader
StoreClient
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 routingDelegatingStore
RebootstrappingStore
.
AbstractStorageEngine.getAndLock(Object)
call.
RepairJob
Store
.
RequestFormatType
RequestFormatType
.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.
AdminClient
AdminClient
RequestFormat
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 |