Modifier and Type | Method and Description |
---|---|
Range<Token> |
RingCache.getRange(java.nio.ByteBuffer key) |
Modifier and Type | Method and Description |
---|---|
java.util.List<java.net.InetAddress> |
RingCache.getEndpoint(Range<Token> range)
ListMultimap promises to return a List for get(K)
|
Modifier and Type | Method and Description |
---|---|
Token |
DecoratedKey.getToken() |
Modifier and Type | Method and Description |
---|---|
static java.util.Set<Range<Token>> |
SystemKeyspace.getAvailableRanges(java.lang.String keyspace,
IPartitioner partitioner) |
static java.util.Collection<Token> |
SystemKeyspace.getSavedTokens() |
static java.util.Map<java.net.InetAddress,java.util.Set<Range<Token>>> |
SystemKeyspace.getTransferredRanges(java.lang.String description,
java.lang.String keyspace,
IPartitioner partitioner) |
static Pair<java.lang.Integer,Token> |
SystemKeyspace.getViewBuildStatus(java.lang.String ksname,
java.lang.String viewName) |
static com.google.common.collect.SetMultimap<java.net.InetAddress,Token> |
SystemKeyspace.loadTokens()
Return a map of stored tokens to IP addresses
|
Modifier and Type | Method and Description |
---|---|
static void |
SystemKeyspace.updateViewBuildStatus(java.lang.String ksname,
java.lang.String viewName,
Token token) |
Modifier and Type | Method and Description |
---|---|
long |
ColumnFamilyStore.estimatedKeysForRange(Range<Token> range) |
void |
ColumnFamilyStore.forceCompactionForTokenRange(java.util.Collection<Range<Token>> tokenRanges) |
void |
ColumnFamilyStoreMBean.forceCompactionForTokenRange(java.util.Collection<Range<Token>> tokenRanges)
force a major compaction of specified key range in this column family
|
static DataRange |
DataRange.forTokenRange(Range<Token> tokenRange)
Creates a
DataRange to query all rows over the provided token range. |
int |
ColumnFamilyStore.invalidateCounterCache(java.util.Collection<Bounds<Token>> boundsToInvalidate) |
int |
ColumnFamilyStore.invalidateRowCache(java.util.Collection<Bounds<Token>> boundsToInvalidate) |
java.lang.Iterable<DecoratedKey> |
ColumnFamilyStore.keySamples(Range<Token> range) |
static void |
SystemKeyspace.updateAvailableRanges(java.lang.String keyspace,
java.util.Collection<Range<Token>> completedRanges) |
static void |
SystemKeyspace.updateSizeEstimates(java.lang.String keyspace,
java.lang.String table,
java.util.Map<Range<Token>,Pair<java.lang.Long,java.lang.Long>> estimates)
Writes the current partition count and size estimates into SIZE_ESTIMATES_CF
|
static void |
SystemKeyspace.updateTokens(java.util.Collection<Token> tokens)
This method is used to update the System Keyspace with the new tokens for this node
|
static java.util.concurrent.Future<?> |
SystemKeyspace.updateTokens(java.net.InetAddress ep,
java.util.Collection<Token> tokens,
java.util.concurrent.ExecutorService executorService)
Record tokens being used by another node
|
static void |
SystemKeyspace.updateTransferredRanges(java.lang.String description,
java.net.InetAddress peer,
java.lang.String keyspace,
java.util.Collection<Range<Token>> streamedRanges) |
Constructor and Description |
---|
BufferDecoratedKey(Token token,
java.nio.ByteBuffer key) |
CachedHashDecoratedKey(Token token,
java.nio.ByteBuffer key) |
DecoratedKey(Token token) |
NativeDecoratedKey(Token token,
NativeAllocator allocator,
OpOrder.Group writeOp,
java.nio.ByteBuffer key) |
PreHashedDecoratedKey(Token token,
java.nio.ByteBuffer key,
long hash0,
long hash1) |
Modifier and Type | Method and Description |
---|---|
void |
CompactionManager.forceCompactionForTokenRange(ColumnFamilyStore cfStore,
java.util.Collection<Range<Token>> ranges) |
AbstractCompactionStrategy.ScannerList |
AbstractCompactionStrategy.getScanners(java.util.Collection<SSTableReader> sstables,
java.util.Collection<Range<Token>> ranges)
Returns a list of KeyScanners given sstables and a range on which to scan.
|
AbstractCompactionStrategy.ScannerList |
CompactionStrategyManager.getScanners(java.util.Collection<SSTableReader> sstables,
java.util.Collection<Range<Token>> ranges)
Create ISSTableScanners from the given sstables
Delegates the call to the compaction strategies to allow LCS to create a scanner
|
AbstractCompactionStrategy.ScannerList |
LeveledCompactionStrategy.getScanners(java.util.Collection<SSTableReader> sstables,
java.util.Collection<Range<Token>> ranges) |
AbstractCompactionStrategy.ScannerList |
AbstractCompactionStrategy.getScanners(java.util.Collection<SSTableReader> sstables,
Range<Token> range) |
static boolean |
CompactionManager.needsCleanup(SSTableReader sstable,
java.util.Collection<Range<Token>> ownedRanges)
Determines if a cleanup would actually remove any data in this SSTable based
on a set of owned ranges.
|
void |
CompactionManager.performAnticompaction(ColumnFamilyStore cfs,
java.util.Collection<Range<Token>> ranges,
Refs<SSTableReader> validatedForRepair,
LifecycleTransaction txn,
long repairedAt,
java.util.UUID parentRepairSession)
Make sure the {validatedForRepair} are marked for compaction before calling this.
|
com.google.common.util.concurrent.ListenableFuture<?> |
CompactionManager.submitAntiCompaction(ColumnFamilyStore cfs,
java.util.Collection<Range<Token>> ranges,
Refs<SSTableReader> sstables,
long repairedAt,
java.util.UUID parentRepairSession)
Submit anti-compactions for a collection of SSTables over a set of repaired ranges and marks corresponding SSTables
as repaired.
|
Modifier and Type | Method and Description |
---|---|
static java.util.Optional<java.net.InetAddress> |
ViewUtils.getViewNaturalEndpoint(java.lang.String keyspaceName,
Token baseToken,
Token viewToken)
Calculate the natural endpoint for the view.
|
Modifier and Type | Class and Description |
---|---|
static class |
ByteOrderedPartitioner.BytesToken |
class |
LocalPartitioner.LocalToken |
static class |
Murmur3Partitioner.LongToken |
static class |
OrderPreservingPartitioner.StringToken |
static class |
RandomPartitioner.BigIntegerToken |
Modifier and Type | Field and Description |
---|---|
protected java.util.Collection<Token> |
BootStrapper.tokens |
static IPartitionerDependentSerializer<AbstractBounds<Token>> |
AbstractBounds.tokenSerializer |
Modifier and Type | Method and Description |
---|---|
Token |
Token.TokenSerializer.deserialize(java.io.DataInput in,
IPartitioner p,
int version) |
abstract Token |
Token.TokenFactory.fromByteArray(java.nio.ByteBuffer bytes) |
abstract Token |
Token.TokenFactory.fromString(java.lang.String string) |
default Token |
IPartitioner.getMaximumToken()
The biggest token for this partitioner, unlike getMinimumToken, this token is actually used and users wanting to
include all tokens need to do getMaximumToken().maxKeyBound()
Not implemented for the ordered partitioners
|
Token |
Murmur3Partitioner.getMaximumToken() |
Token |
RandomPartitioner.getMaximumToken() |
Token |
IPartitioner.getMinimumToken() |
Token |
IPartitioner.getRandomToken() |
Token |
IPartitioner.getRandomToken(java.util.Random random) |
Token |
RingPosition.getToken() |
Token |
Token.getToken() |
Token |
Token.KeyBound.getToken() |
Token |
IPartitioner.getToken(java.nio.ByteBuffer key) |
Token |
ByteOrderedPartitioner.BytesToken.increaseSlightly() |
Token |
Murmur3Partitioner.LongToken.increaseSlightly() |
Token |
RandomPartitioner.BigIntegerToken.increaseSlightly() |
abstract Token |
Token.increaseSlightly()
Returns a token that is slightly greater than this.
|
Token |
IPartitioner.midpoint(Token left,
Token right)
Calculate a Token representing the approximate "middle" of the given
range.
|
Token |
LocalPartitioner.midpoint(Token left,
Token right) |
Token |
Murmur3Partitioner.midpoint(Token lToken,
Token rToken) |
Token |
RandomPartitioner.midpoint(Token ltoken,
Token rtoken) |
Token |
Token.minValue() |
Token |
ByteOrderedPartitioner.split(Token left,
Token right,
double ratioToLeft) |
Token |
IPartitioner.split(Token left,
Token right,
double ratioToLeft)
Calculate a Token which take approximate 0 <= ratioToLeft <= 1 ownership of the given range.
|
Token |
LocalPartitioner.split(Token left,
Token right,
double ratioToLeft) |
Token |
Murmur3Partitioner.split(Token lToken,
Token rToken,
double ratioToLeft) |
Token |
OrderPreservingPartitioner.split(Token left,
Token right,
double ratioToLeft) |
Token |
RandomPartitioner.split(Token ltoken,
Token rtoken,
double ratioToLeft) |
protected abstract Token |
Splitter.tokenForValue(java.math.BigInteger value) |
Modifier and Type | Method and Description |
---|---|
java.util.Map<Token,java.lang.Float> |
ByteOrderedPartitioner.describeOwnership(java.util.List<Token> sortedTokens) |
java.util.Map<Token,java.lang.Float> |
IPartitioner.describeOwnership(java.util.List<Token> sortedTokens)
Calculate the deltas between tokens in the ring in order to compare
relative sizes.
|
java.util.Map<Token,java.lang.Float> |
LocalPartitioner.describeOwnership(java.util.List<Token> sortedTokens) |
java.util.Map<Token,java.lang.Float> |
Murmur3Partitioner.describeOwnership(java.util.List<Token> sortedTokens) |
java.util.Map<Token,java.lang.Float> |
OrderPreservingPartitioner.describeOwnership(java.util.List<Token> sortedTokens) |
java.util.Map<Token,java.lang.Float> |
RandomPartitioner.describeOwnership(java.util.List<Token> sortedTokens) |
java.util.Set<Range<Token>> |
StreamStateStore.getAvailableRanges(java.lang.String keyspace,
IPartitioner partitioner) |
static java.util.Collection<Token> |
BootStrapper.getBootstrapTokens(TokenMetadata metadata,
java.net.InetAddress address,
int schemaWaitDelay)
if initialtoken was specified, use that (split on comma).
|
static java.util.Collection<Token> |
BootStrapper.getRandomTokens(TokenMetadata metadata,
int numTokens) |
static com.google.common.collect.Multimap<java.net.InetAddress,Range<Token>> |
RangeStreamer.getWorkMap(com.google.common.collect.Multimap<Range<Token>,java.net.InetAddress> rangesWithSourceTarget,
java.lang.String keyspace,
IFailureDetector fd,
boolean useStrictConsistency) |
java.util.List<Token> |
Splitter.splitOwnedRanges(int parts,
java.util.List<Range<Token>> localRanges,
boolean dontSplitRanges) |
Modifier and Type | Method and Description |
---|---|
int |
ByteOrderedPartitioner.BytesToken.compareTo(Token other) |
int |
LocalPartitioner.LocalToken.compareTo(Token o) |
int |
Murmur3Partitioner.LongToken.compareTo(Token o) |
boolean |
Range.OrderedRangeContainmentChecker.contains(Token t)
Returns true if the ranges given in the constructor contains the token, false otherwise.
|
boolean |
StreamStateStore.isDataAvailable(java.lang.String keyspace,
Token token)
Check if given token's data is available in this node.
|
static Bounds<PartitionPosition> |
Bounds.makeRowBounds(Token left,
Token right)
Compute a bounds of keys corresponding to a given bounds of token.
|
static Range<PartitionPosition> |
Range.makeRowRange(Token left,
Token right)
Compute a range of keys corresponding to a given range of token.
|
ByteOrderedPartitioner.BytesToken |
ByteOrderedPartitioner.midpoint(Token lt,
Token rt) |
Token |
IPartitioner.midpoint(Token left,
Token right)
Calculate a Token representing the approximate "middle" of the given
range.
|
Token |
LocalPartitioner.midpoint(Token left,
Token right) |
Token |
Murmur3Partitioner.midpoint(Token lToken,
Token rToken) |
OrderPreservingPartitioner.StringToken |
OrderPreservingPartitioner.midpoint(Token ltoken,
Token rtoken) |
Token |
RandomPartitioner.midpoint(Token ltoken,
Token rtoken) |
void |
Token.TokenSerializer.serialize(Token token,
DataOutputPlus out,
int version) |
long |
Token.TokenSerializer.serializedSize(Token object,
int version) |
double |
ByteOrderedPartitioner.BytesToken.size(Token next) |
double |
Murmur3Partitioner.LongToken.size(Token next) |
double |
RandomPartitioner.BigIntegerToken.size(Token next) |
abstract double |
Token.size(Token next)
Returns a measure for the token space covered between this token and next.
|
Token |
ByteOrderedPartitioner.split(Token left,
Token right,
double ratioToLeft) |
Token |
IPartitioner.split(Token left,
Token right,
double ratioToLeft)
Calculate a Token which take approximate 0 <= ratioToLeft <= 1 ownership of the given range.
|
Token |
LocalPartitioner.split(Token left,
Token right,
double ratioToLeft) |
Token |
Murmur3Partitioner.split(Token lToken,
Token rToken,
double ratioToLeft) |
Token |
OrderPreservingPartitioner.split(Token left,
Token right,
double ratioToLeft) |
Token |
RandomPartitioner.split(Token ltoken,
Token rtoken,
double ratioToLeft) |
abstract java.nio.ByteBuffer |
Token.TokenFactory.toByteArray(Token token) |
abstract java.lang.String |
Token.TokenFactory.toString(Token token) |
protected abstract java.math.BigInteger |
Splitter.valueForToken(Token token) |
Modifier and Type | Method and Description |
---|---|
void |
RangeStreamer.addRanges(java.lang.String keyspaceName,
java.util.Collection<Range<Token>> ranges)
Add ranges to be streamed for given keyspace.
|
java.util.Map<Token,java.lang.Float> |
ByteOrderedPartitioner.describeOwnership(java.util.List<Token> sortedTokens) |
java.util.Map<Token,java.lang.Float> |
IPartitioner.describeOwnership(java.util.List<Token> sortedTokens)
Calculate the deltas between tokens in the ring in order to compare
relative sizes.
|
java.util.Map<Token,java.lang.Float> |
LocalPartitioner.describeOwnership(java.util.List<Token> sortedTokens) |
java.util.Map<Token,java.lang.Float> |
Murmur3Partitioner.describeOwnership(java.util.List<Token> sortedTokens) |
java.util.Map<Token,java.lang.Float> |
OrderPreservingPartitioner.describeOwnership(java.util.List<Token> sortedTokens) |
java.util.Map<Token,java.lang.Float> |
RandomPartitioner.describeOwnership(java.util.List<Token> sortedTokens) |
static com.google.common.collect.Multimap<java.net.InetAddress,Range<Token>> |
RangeStreamer.getWorkMap(com.google.common.collect.Multimap<Range<Token>,java.net.InetAddress> rangesWithSourceTarget,
java.lang.String keyspace,
IFailureDetector fd,
boolean useStrictConsistency) |
static Range<PartitionPosition> |
Range.makeRowRange(Range<Token> tokenBounds) |
java.util.List<Token> |
Splitter.splitOwnedRanges(int parts,
java.util.List<Range<Token>> localRanges,
boolean dontSplitRanges) |
Constructor and Description |
---|
BootStrapper(java.net.InetAddress address,
java.util.Collection<Token> tokens,
TokenMetadata tmd) |
OrderedRangeContainmentChecker(java.util.Collection<Range<Token>> ranges) |
RangeStreamer(TokenMetadata metadata,
java.util.Collection<Token> tokens,
java.net.InetAddress address,
java.lang.String description,
boolean useStrictConsistency,
IEndpointSnitch snitch,
StreamStateStore stateStore,
boolean connectSequentially) |
Modifier and Type | Method and Description |
---|---|
java.util.Collection<Token> |
NoReplicationTokenAllocator.addUnit(Unit newUnit,
int numTokens) |
java.util.Collection<Token> |
TokenAllocator.addUnit(Unit newUnit,
int numTokens) |
static java.util.Collection<Token> |
TokenAllocation.allocateTokens(TokenMetadata tokenMetadata,
AbstractReplicationStrategy rs,
java.net.InetAddress endpoint,
int numTokens) |
Modifier and Type | Method and Description |
---|---|
static TokenAllocator<java.net.InetAddress> |
TokenAllocatorFactory.createTokenAllocator(java.util.NavigableMap<Token,java.net.InetAddress> sortedTokens,
org.apache.cassandra.dht.tokenallocator.ReplicationStrategy<java.net.InetAddress> strategy,
IPartitioner partitioner) |
Constructor and Description |
---|
NoReplicationTokenAllocator(java.util.NavigableMap<Token,Unit> sortedTokens,
org.apache.cassandra.dht.tokenallocator.ReplicationStrategy<Unit> strategy,
IPartitioner partitioner) |
TokenAllocatorBase(java.util.NavigableMap<Token,Unit> sortedTokens,
org.apache.cassandra.dht.tokenallocator.ReplicationStrategy<Unit> strategy,
IPartitioner partitioner) |
Modifier and Type | Method and Description |
---|---|
static java.util.Collection<Token> |
TokenSerializer.deserialize(IPartitioner partitioner,
java.io.DataInput in) |
Modifier and Type | Method and Description |
---|---|
VersionedValue |
VersionedValue.VersionedValueFactory.moving(Token token) |
Modifier and Type | Method and Description |
---|---|
VersionedValue |
VersionedValue.VersionedValueFactory.bootstrapping(java.util.Collection<Token> tokens) |
VersionedValue |
VersionedValue.VersionedValueFactory.leaving(java.util.Collection<Token> tokens) |
VersionedValue |
VersionedValue.VersionedValueFactory.left(java.util.Collection<Token> tokens,
long expireTime) |
VersionedValue |
VersionedValue.VersionedValueFactory.normal(java.util.Collection<Token> tokens) |
static void |
TokenSerializer.serialize(IPartitioner partitioner,
java.util.Collection<Token> tokens,
java.io.DataOutput out) |
VersionedValue |
VersionedValue.VersionedValueFactory.tokens(java.util.Collection<Token> tokens) |
Modifier and Type | Method and Description |
---|---|
java.util.Map<java.net.InetAddress,java.util.Collection<Range<Token>>> |
SSTableLoader.Client.getEndpointToRangesMap() |
Modifier and Type | Method and Description |
---|---|
protected void |
SSTableLoader.Client.addRangeForEndpoint(Range<Token> range,
java.net.InetAddress endpoint) |
protected java.util.Collection<SSTableReader> |
SSTableLoader.openSSTables(java.util.Map<java.net.InetAddress,java.util.Collection<Range<Token>>> ranges) |
Modifier and Type | Method and Description |
---|---|
long |
SSTableReader.estimatedKeysForRanges(java.util.Collection<Range<Token>> ranges) |
java.lang.Iterable<DecoratedKey> |
SSTableReader.getKeySamples(Range<Token> range) |
java.util.List<Pair<java.lang.Long,java.lang.Long>> |
SSTableReader.getPositionsForRanges(java.util.Collection<Range<Token>> ranges)
Determine the minimal set of sections that can be extracted from this SSTable to cover the given ranges.
|
abstract ISSTableScanner |
SSTableReader.getScanner(java.util.Collection<Range<Token>> ranges,
com.google.common.util.concurrent.RateLimiter limiter)
Direct I/O SSTableScanner over a defined collection of ranges of tokens.
|
ISSTableScanner |
SSTableReader.getScanner(Range<Token> range,
com.google.common.util.concurrent.RateLimiter limiter)
Direct I/O SSTableScanner over a defined range of tokens.
|
Modifier and Type | Method and Description |
---|---|
ISSTableScanner |
BigTableReader.getScanner(java.util.Collection<Range<Token>> ranges,
com.google.common.util.concurrent.RateLimiter limiter)
Direct I/O SSTableScanner over a defined collection of ranges of tokens.
|
static ISSTableScanner |
BigTableScanner.getScanner(SSTableReader sstable,
java.util.Collection<Range<Token>> tokenRanges,
com.google.common.util.concurrent.RateLimiter limiter) |
Modifier and Type | Method and Description |
---|---|
static Token |
TokenMetadata.firstToken(java.util.ArrayList<Token> ring,
Token start) |
Token |
TokenMetadata.getPredecessor(Token token) |
Token |
TokenMetadata.getSuccessor(Token token) |
Token |
TokenMetadata.getToken(java.net.InetAddress endpoint)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
com.google.common.collect.Multimap<java.net.InetAddress,Range<Token>> |
AbstractReplicationStrategy.getAddressRanges() |
com.google.common.collect.Multimap<java.net.InetAddress,Range<Token>> |
AbstractReplicationStrategy.getAddressRanges(TokenMetadata metadata) |
BiMultiValMap<Token,java.net.InetAddress> |
TokenMetadata.getBootstrapTokens() |
com.google.common.collect.Multimap<java.net.InetAddress,Token> |
TokenMetadata.getEndpointToTokenMapForReading() |
java.util.Set<Pair<Token,java.net.InetAddress>> |
TokenMetadata.getMovingEndpoints()
Endpoints which are migrating to the new tokens
|
java.util.Map<Token,java.net.InetAddress> |
TokenMetadata.getNormalAndBootstrappingTokenToEndpointMap() |
java.util.Collection<Range<Token>> |
AbstractReplicationStrategy.getPendingAddressRanges(TokenMetadata metadata,
java.util.Collection<Token> pendingTokens,
java.net.InetAddress pendingAddress) |
java.util.Collection<Range<Token>> |
AbstractReplicationStrategy.getPendingAddressRanges(TokenMetadata metadata,
Token pendingToken,
java.net.InetAddress pendingAddress) |
java.util.List<Range<Token>> |
TokenMetadata.getPendingRanges(java.lang.String keyspaceName,
java.net.InetAddress endpoint) |
com.google.common.collect.Multimap<Range<Token>,java.net.InetAddress> |
TokenMetadata.getPendingRangesMM(java.lang.String keyspaceName) |
Range<Token> |
TokenMetadata.getPrimaryRangeFor(Token right)
Deprecated.
|
java.util.Collection<Range<Token>> |
TokenMetadata.getPrimaryRangesFor(java.util.Collection<Token> tokens) |
com.google.common.collect.Multimap<Range<Token>,java.net.InetAddress> |
AbstractReplicationStrategy.getRangeAddresses(TokenMetadata metadata) |
java.util.Collection<Token> |
TokenMetadata.getTokens(java.net.InetAddress endpoint) |
java.util.Iterator<java.util.Map.Entry<Range<Token>,java.util.List<java.net.InetAddress>>> |
PendingRangeMaps.iterator() |
static java.util.Iterator<Token> |
TokenMetadata.ringIterator(java.util.ArrayList<Token> ring,
Token start,
boolean includeMin)
iterator over the Tokens in the given ring, starting with the token for the node owning start
(which does not have to be a Token in the ring)
|
java.util.ArrayList<Token> |
TokenMetadata.sortedTokens() |
Modifier and Type | Method and Description |
---|---|
void |
TokenMetadata.addBootstrapToken(Token token,
java.net.InetAddress endpoint)
Deprecated.
|
void |
TokenMetadata.addMovingEndpoint(Token token,
java.net.InetAddress endpoint)
Add a new moving endpoint
|
abstract java.util.List<java.net.InetAddress> |
AbstractReplicationStrategy.calculateNaturalEndpoints(Token searchToken,
TokenMetadata tokenMetadata)
calculate the natural endpoints for the given token
|
java.util.List<java.net.InetAddress> |
LocalStrategy.calculateNaturalEndpoints(Token token,
TokenMetadata metadata) |
java.util.List<java.net.InetAddress> |
NetworkTopologyStrategy.calculateNaturalEndpoints(Token searchToken,
TokenMetadata tokenMetadata)
calculate endpoints in one pass through the tokens by tracking our progress in each DC.
|
java.util.List<java.net.InetAddress> |
OldNetworkTopologyStrategy.calculateNaturalEndpoints(Token token,
TokenMetadata metadata) |
java.util.List<java.net.InetAddress> |
SimpleStrategy.calculateNaturalEndpoints(Token token,
TokenMetadata metadata) |
static Token |
TokenMetadata.firstToken(java.util.ArrayList<Token> ring,
Token start) |
static int |
TokenMetadata.firstTokenIndex(java.util.ArrayList<Token> ring,
Token start,
boolean insertMin) |
java.util.ArrayList<java.net.InetAddress> |
AbstractReplicationStrategy.getCachedEndpoints(Token t) |
java.net.InetAddress |
TokenMetadata.getEndpoint(Token token) |
java.util.Collection<Range<Token>> |
AbstractReplicationStrategy.getPendingAddressRanges(TokenMetadata metadata,
Token pendingToken,
java.net.InetAddress pendingAddress) |
Token |
TokenMetadata.getPredecessor(Token token) |
Range<Token> |
TokenMetadata.getPrimaryRangeFor(Token right)
Deprecated.
|
Token |
TokenMetadata.getSuccessor(Token token) |
java.util.Collection<java.net.InetAddress> |
TokenMetadata.getWriteEndpoints(Token token,
java.lang.String keyspaceName,
java.util.Collection<java.net.InetAddress> naturalEndpoints)
Deprecated.
retained for benefit of old tests
|
java.util.Collection<java.net.InetAddress> |
PendingRangeMaps.pendingEndpointsFor(Token token) |
java.util.Collection<java.net.InetAddress> |
TokenMetadata.pendingEndpointsFor(Token token,
java.lang.String keyspaceName) |
static java.util.Iterator<Token> |
TokenMetadata.ringIterator(java.util.ArrayList<Token> ring,
Token start,
boolean includeMin)
iterator over the Tokens in the given ring, starting with the token for the node owning start
(which does not have to be a Token in the ring)
|
void |
TokenMetadata.updateNormalToken(Token token,
java.net.InetAddress endpoint)
Update token map with a single token/endpoint pair in normal state.
|
Modifier and Type | Method and Description |
---|---|
void |
TokenMetadata.addBootstrapTokens(java.util.Collection<Token> tokens,
java.net.InetAddress endpoint) |
void |
PendingRangeMaps.addPendingRange(Range<Token> range,
java.net.InetAddress address) |
void |
TokenMetadata.addReplaceTokens(java.util.Collection<Token> replacingTokens,
java.net.InetAddress newNode,
java.net.InetAddress oldNode) |
static Token |
TokenMetadata.firstToken(java.util.ArrayList<Token> ring,
Token start) |
static int |
TokenMetadata.firstTokenIndex(java.util.ArrayList<Token> ring,
Token start,
boolean insertMin) |
java.util.Collection<Range<Token>> |
AbstractReplicationStrategy.getPendingAddressRanges(TokenMetadata metadata,
java.util.Collection<Token> pendingTokens,
java.net.InetAddress pendingAddress) |
java.util.Collection<Range<Token>> |
TokenMetadata.getPrimaryRangesFor(java.util.Collection<Token> tokens) |
void |
TokenMetadata.removeBootstrapTokens(java.util.Collection<Token> tokens) |
static java.util.Iterator<Token> |
TokenMetadata.ringIterator(java.util.ArrayList<Token> ring,
Token start,
boolean includeMin)
iterator over the Tokens in the given ring, starting with the token for the node owning start
(which does not have to be a Token in the ring)
|
void |
TokenMetadata.updateNormalTokens(java.util.Collection<Token> tokens,
java.net.InetAddress endpoint) |
void |
TokenMetadata.updateNormalTokens(com.google.common.collect.Multimap<java.net.InetAddress,Token> endpointTokens)
Update token map with a set of token/endpoint pairs in normal state.
|
Modifier and Type | Field and Description |
---|---|
java.util.Collection<Range<Token>> |
RepairJobDesc.ranges
repairing range
|
java.util.Collection<Range<Token>> |
RepairSession.ranges
Range to repair
|
java.util.Collection<Range<Token>> |
RepairSessionResult.ranges |
Modifier and Type | Method and Description |
---|---|
java.util.Collection<Range<Token>> |
RepairSession.getRanges() |
Modifier and Type | Method and Description |
---|---|
boolean |
Validator.findCorrectRange(Token t) |
Modifier and Type | Method and Description |
---|---|
static void |
SystemDistributedKeyspace.startRepairs(java.util.UUID id,
java.util.UUID parent_id,
java.lang.String keyspaceName,
java.lang.String[] cfnames,
java.util.Collection<Range<Token>> ranges,
java.lang.Iterable<java.net.InetAddress> endpoints) |
protected void |
LocalSyncTask.startSync(java.util.List<Range<Token>> differences)
Starts sending/receiving our list of differences to/from the remote endpoint: creates a callback
that will be called out of band once the streams complete.
|
protected void |
RemoteSyncTask.startSync(java.util.List<Range<Token>> differences) |
protected abstract void |
SyncTask.startSync(java.util.List<Range<Token>> differences) |
static void |
SystemDistributedKeyspace.successfulParentRepair(java.util.UUID parent_id,
java.util.Collection<Range<Token>> successfulRanges) |
Constructor and Description |
---|
AnticompactionTask(java.util.UUID parentSession,
java.net.InetAddress neighbor,
java.util.Collection<Range<Token>> successfulRanges) |
RepairJobDesc(java.util.UUID parentSessionId,
java.util.UUID sessionId,
java.lang.String keyspace,
java.lang.String columnFamily,
java.util.Collection<Range<Token>> ranges) |
RepairSession(java.util.UUID parentRepairSession,
java.util.UUID id,
java.util.Collection<Range<Token>> ranges,
java.lang.String keyspace,
RepairParallelism parallelismDegree,
java.util.Set<java.net.InetAddress> endpoints,
long repairedAt,
boolean pullRepair,
java.lang.String... cfnames)
Create new repair session.
|
RepairSessionResult(java.util.UUID sessionId,
java.lang.String keyspace,
java.util.Collection<Range<Token>> ranges,
java.util.Collection<RepairResult> repairJobResults) |
Modifier and Type | Field and Description |
---|---|
java.util.Collection<Range<Token>> |
PrepareMessage.ranges |
java.util.Collection<Range<Token>> |
SyncRequest.ranges |
java.util.Collection<Range<Token>> |
AnticompactionRequest.successfulRanges
Successfully repaired ranges.
|
Modifier and Type | Method and Description |
---|---|
java.util.Collection<Range<Token>> |
RepairOption.getRanges() |
Constructor and Description |
---|
AnticompactionRequest(java.util.UUID parentRepairSession,
java.util.Collection<Range<Token>> ranges) |
PrepareMessage(java.util.UUID parentRepairSession,
java.util.List<java.util.UUID> cfIds,
java.util.Collection<Range<Token>> ranges,
boolean isIncremental,
long timestamp,
boolean isGlobal) |
RepairOption(RepairParallelism parallelism,
boolean primaryRange,
boolean incremental,
boolean trace,
int jobThreads,
java.util.Collection<Range<Token>> ranges,
boolean isSubrangeRepair,
boolean pullRepair) |
SyncRequest(RepairJobDesc desc,
java.net.InetAddress initiator,
java.net.InetAddress src,
java.net.InetAddress dst,
java.util.Collection<Range<Token>> ranges) |
Modifier and Type | Method and Description |
---|---|
Pair<java.util.Set<Range<Token>>,java.util.Set<Range<Token>>> |
StorageService.calculateStreamAndFetchRanges(java.util.Collection<Range<Token>> current,
java.util.Collection<Range<Token>> updated)
Calculate pair of ranges to stream/fetch for given two range collections
(current ranges for keyspace and ranges after move to new token)
|
Pair<java.util.Set<Range<Token>>,java.util.Set<Range<Token>>> |
StorageService.calculateStreamAndFetchRanges(java.util.Collection<Range<Token>> current,
java.util.Collection<Range<Token>> updated)
Calculate pair of ranges to stream/fetch for given two range collections
(current ranges for keyspace and ranges after move to new token)
|
java.util.List<Range<Token>> |
StorageService.getAllRanges(java.util.List<Token> sortedTokens)
Get all ranges that span the ring given a set
of tokens.
|
java.util.Collection<Range<Token>> |
StorageService.getLocalRanges(java.lang.String keyspaceName) |
java.util.Collection<Token> |
StorageService.getLocalTokens() |
java.util.Collection<Range<Token>> |
StorageService.getPrimaryRangeForEndpointWithinDC(java.lang.String keyspace,
java.net.InetAddress referenceEndpoint)
Get the "primary ranges" within local DC for the specified keyspace and endpoint.
|
java.util.Collection<Range<Token>> |
StorageService.getPrimaryRanges(java.lang.String keyspace) |
java.util.Collection<Range<Token>> |
StorageService.getPrimaryRangesForEndpoint(java.lang.String keyspace,
java.net.InetAddress ep)
Get the "primary ranges" for the specified keyspace and endpoint.
|
java.util.Collection<Range<Token>> |
StorageService.getPrimaryRangesWithinDC(java.lang.String keyspace) |
java.util.Map<Range<Token>,java.util.List<java.net.InetAddress>> |
StorageService.getRangeToAddressMap(java.lang.String keyspace) |
java.util.Map<Range<Token>,java.util.List<java.net.InetAddress>> |
StorageService.getRangeToAddressMapInLocalDC(java.lang.String keyspace) |
java.util.List<Pair<Range<Token>,java.lang.Long>> |
StorageService.getSplits(java.lang.String keyspaceName,
java.lang.String cfName,
Range<Token> range,
int keysPerSplit) |
Modifier and Type | Method and Description |
---|---|
java.lang.Iterable<java.net.InetAddress> |
StorageService.getNaturalAndPendingEndpoints(java.lang.String keyspaceName,
Token token)
Returns the endpoints currently responsible for storing the token plus pending ones
|
Modifier and Type | Method and Description |
---|---|
Pair<java.util.Set<Range<Token>>,java.util.Set<Range<Token>>> |
StorageService.calculateStreamAndFetchRanges(java.util.Collection<Range<Token>> current,
java.util.Collection<Range<Token>> updated)
Calculate pair of ranges to stream/fetch for given two range collections
(current ranges for keyspace and ranges after move to new token)
|
Pair<java.util.Set<Range<Token>>,java.util.Set<Range<Token>>> |
StorageService.calculateStreamAndFetchRanges(java.util.Collection<Range<Token>> current,
java.util.Collection<Range<Token>> updated)
Calculate pair of ranges to stream/fetch for given two range collections
(current ranges for keyspace and ranges after move to new token)
|
com.google.common.util.concurrent.ListenableFuture<java.util.List<java.lang.Object>> |
ActiveRepairService.doAntiCompaction(java.util.UUID parentRepairSession,
java.util.Collection<Range<Token>> successfulRanges)
Submit anti-compaction jobs to CompactionManager.
|
com.google.common.util.concurrent.ListenableFuture |
ActiveRepairService.finishParentSession(java.util.UUID parentSession,
java.util.Set<java.net.InetAddress> neighbors,
java.util.Collection<Range<Token>> successfulRanges)
Run final process of repair.
|
java.util.List<Range<Token>> |
StorageService.getAllRanges(java.util.List<Token> sortedTokens)
Get all ranges that span the ring given a set
of tokens.
|
static java.util.Set<java.net.InetAddress> |
ActiveRepairService.getNeighbors(java.lang.String keyspaceName,
java.util.Collection<Range<Token>> keyspaceLocalRanges,
Range<Token> toRepair,
java.util.Collection<java.lang.String> dataCenters,
java.util.Collection<java.lang.String> hosts)
Return all of the neighbors with whom we share the provided range.
|
static java.util.Set<java.net.InetAddress> |
ActiveRepairService.getNeighbors(java.lang.String keyspaceName,
java.util.Collection<Range<Token>> keyspaceLocalRanges,
Range<Token> toRepair,
java.util.Collection<java.lang.String> dataCenters,
java.util.Collection<java.lang.String> hosts)
Return all of the neighbors with whom we share the provided range.
|
java.util.List<Pair<Range<Token>,java.lang.Long>> |
StorageService.getSplits(java.lang.String keyspaceName,
java.lang.String cfName,
Range<Token> range,
int keysPerSplit) |
void |
ActiveRepairService.registerParentRepairSession(java.util.UUID parentRepairSession,
java.net.InetAddress coordinator,
java.util.List<ColumnFamilyStore> columnFamilyStores,
java.util.Collection<Range<Token>> ranges,
boolean isIncremental,
long timestamp,
boolean isGlobal) |
void |
StorageService.setGossipTokens(java.util.Collection<Token> tokens) |
void |
StorageService.setTokens(java.util.Collection<Token> tokens)
This method updates the local token on disk
|
RepairSession |
ActiveRepairService.submitRepairSession(java.util.UUID parentRepairSession,
java.util.Collection<Range<Token>> range,
java.lang.String keyspace,
RepairParallelism parallelismDegree,
java.util.Set<java.net.InetAddress> endpoints,
long repairedAt,
boolean pullRepair,
com.google.common.util.concurrent.ListeningExecutorService executor,
java.lang.String... cfnames)
Requests repairs for the given keyspace and column families.
|
Constructor and Description |
---|
ParentRepairSession(java.net.InetAddress coordinator,
java.util.List<ColumnFamilyStore> columnFamilyStores,
java.util.Collection<Range<Token>> ranges,
boolean isIncremental,
long repairedAt,
boolean isGlobal) |
Modifier and Type | Field and Description |
---|---|
java.util.Collection<Range<Token>> |
StreamRequest.ranges |
java.util.Map<java.lang.String,java.util.Set<Range<Token>>> |
StreamEvent.SessionCompleteEvent.transferredRangesPerKeyspace |
java.util.Map<java.lang.String,java.util.Set<Range<Token>>> |
StreamSession.transferredRangesPerKeyspace |
Modifier and Type | Method and Description |
---|---|
void |
StreamSession.addStreamRequest(java.lang.String keyspace,
java.util.Collection<Range<Token>> ranges,
java.util.Collection<java.lang.String> columnFamilies,
long repairedAt)
Request data fetch task to this session.
|
void |
StreamSession.addTransferRanges(java.lang.String keyspace,
java.util.Collection<Range<Token>> ranges,
java.util.Collection<java.lang.String> columnFamilies,
boolean flushTables,
long repairedAt)
Set up transfer for specific keyspace/ranges/CFs
Used in repair - a streamed sstable in repair will be marked with the given repairedAt time
|
static java.util.List<StreamSession.SSTableStreamingSections> |
StreamSession.getSSTableSectionsForRanges(java.util.Collection<Range<Token>> ranges,
java.util.Collection<ColumnFamilyStore> stores,
long overriddenRepairedAt,
boolean isIncremental) |
StreamPlan |
StreamPlan.requestRanges(java.net.InetAddress from,
java.net.InetAddress connecting,
java.lang.String keyspace,
java.util.Collection<Range<Token>> ranges)
Request data in
keyspace and ranges from specific node. |
StreamPlan |
StreamPlan.requestRanges(java.net.InetAddress from,
java.net.InetAddress connecting,
java.lang.String keyspace,
java.util.Collection<Range<Token>> ranges,
java.lang.String... columnFamilies)
Request data in
columnFamilies under keyspace and ranges from specific node. |
StreamPlan |
StreamPlan.transferRanges(java.net.InetAddress to,
java.net.InetAddress connecting,
java.lang.String keyspace,
java.util.Collection<Range<Token>> ranges)
Add transfer task to send data of specific keyspace and ranges.
|
StreamPlan |
StreamPlan.transferRanges(java.net.InetAddress to,
java.net.InetAddress connecting,
java.lang.String keyspace,
java.util.Collection<Range<Token>> ranges,
java.lang.String... columnFamilies)
Add transfer task to send data of specific
columnFamilies under keyspace and ranges . |
StreamPlan |
StreamPlan.transferRanges(java.net.InetAddress to,
java.lang.String keyspace,
java.util.Collection<Range<Token>> ranges,
java.lang.String... columnFamilies)
Add transfer task to send data of specific
columnFamilies under keyspace and ranges . |
Constructor and Description |
---|
StreamRequest(java.lang.String keyspace,
java.util.Collection<Range<Token>> ranges,
java.util.Collection<java.lang.String> columnFamilies,
long repairedAt) |
Modifier and Type | Field and Description |
---|---|
Token |
MerkleTree.RowHash.token |
Modifier and Type | Field and Description |
---|---|
Range<Token> |
MerkleTree.fullRange
The top level range that this MerkleTree covers.
|
Modifier and Type | Method and Description |
---|---|
static java.util.List<Range<Token>> |
MerkleTrees.difference(MerkleTrees ltree,
MerkleTrees rtree)
Get the differences between the two sets of MerkleTrees.
|
java.util.Iterator<java.util.Map.Entry<Range<Token>,MerkleTree>> |
MerkleTrees.iterator()
Get an iterator of all ranges and their MerkleTrees.
|
java.util.Collection<Range<Token>> |
MerkleTrees.ranges()
Get the ranges that these merkle trees covers.
|
Modifier and Type | Method and Description |
---|---|
MerkleTree.TreeRange |
MerkleTree.get(Token t)
For testing purposes.
|
MerkleTree.TreeRange |
MerkleTrees.get(Token t)
Get the MerkleTree.Range responsible for the given token.
|
void |
MerkleTree.invalidate(Token t)
Invalidates the ranges containing the given token.
|
void |
MerkleTrees.invalidate(Token t)
Invalidate the MerkleTree responsible for the given token.
|
boolean |
MerkleTree.split(Token t)
Splits the range containing the given token, if no tree limits would be
violated.
|
boolean |
MerkleTrees.split(Token t)
Split the MerkleTree responsible for the given token.
|
Modifier and Type | Method and Description |
---|---|
MerkleTree |
MerkleTrees.addMerkleTree(int maxsize,
byte hashdepth,
Range<Token> range) |
MerkleTree |
MerkleTrees.addMerkleTree(int maxsize,
Range<Token> range)
Add a MerkleTree with the defined size and range.
|
void |
MerkleTrees.addMerkleTrees(int maxsize,
java.util.Collection<Range<Token>> ranges)
Add merkle tree's with the defined maxsize and ranges.
|
MerkleTree |
MerkleTrees.getMerkleTree(Range<Token> range)
Get the MerkleTree responsible for the given token range.
|
byte[] |
MerkleTree.hash(Range<Token> range)
Hash the given range in the tree.
|
byte[] |
MerkleTrees.hash(Range<Token> range) |
void |
MerkleTrees.init(Range<Token> range)
Init a selected MerkleTree with an even tree distribution.
|
void |
MerkleTrees.maxsize(Range<Token> range,
int maxsize) |
static void |
FBUtilities.sortSampledKeys(java.util.List<DecoratedKey> keys,
Range<Token> range) |
Constructor and Description |
---|
RowHash(Token token,
byte[] hash,
long size) |
TreeDifference(Token left,
Token right,
byte depth) |
Constructor and Description |
---|
MerkleTree(IPartitioner partitioner,
Range<Token> range,
byte hashdepth,
long maxsize) |
Copyright © 2020 The Apache Software Foundation