Modifier and Type | Field and Description |
---|---|
java.util.Set<Range<Token>> |
SystemKeyspace.AvailableRanges.full |
java.util.Set<Range<Token>> |
SystemKeyspace.AvailableRanges.trans |
Modifier and Type | Method and Description |
---|---|
Token |
DecoratedKey.getToken() |
Modifier and Type | Method and Description |
---|---|
static java.util.Collection<Token> |
SystemKeyspace.getSavedTokens() |
static java.util.Map<InetAddressAndPort,java.util.Set<Range<Token>>> |
SystemKeyspace.getTransferredRanges(java.lang.String description,
java.lang.String keyspace,
IPartitioner partitioner) |
static java.util.Map<Range<Token>,Pair<Token,java.lang.Long>> |
SystemKeyspace.getViewBuildStatus(java.lang.String ksname,
java.lang.String viewName) |
static java.util.Map<Range<Token>,Pair<Token,java.lang.Long>> |
SystemKeyspace.getViewBuildStatus(java.lang.String ksname,
java.lang.String viewName) |
static com.google.common.collect.SetMultimap<InetAddressAndPort,Token> |
SystemKeyspace.loadTokens()
Return a map of stored tokens to IP addresses
|
static java.util.Set<Range<Token>> |
SystemKeyspace.rawRangesToRangeSet(java.util.Set<java.nio.ByteBuffer> rawRanges,
IPartitioner partitioner) |
Modifier and Type | Method and Description |
---|---|
static void |
SystemKeyspace.updateViewBuildStatus(java.lang.String ksname,
java.lang.String viewName,
Range<Token> range,
Token lastToken,
long keysBuilt) |
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)
Forces a major compaction of specified token ranges 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>> completedFullRanges,
java.util.Collection<Range<Token>> completedTransientRanges) |
static void |
SystemKeyspace.updateAvailableRanges(java.lang.String keyspace,
java.util.Collection<Range<Token>> completedFullRanges,
java.util.Collection<Range<Token>> completedTransientRanges) |
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.updateTableEstimates(java.lang.String keyspace,
java.lang.String table,
java.lang.String type,
java.util.Map<Range<Token>,Pair<java.lang.Long,java.lang.Long>> estimates)
Writes the current partition count and size estimates into table_estimates
|
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 void |
SystemKeyspace.updateTokens(InetAddressAndPort ep,
java.util.Collection<Token> tokens)
Record tokens being used by another node
|
static void |
SystemKeyspace.updateTransferredRanges(StreamOperation streamOperation,
InetAddressAndPort peer,
java.lang.String keyspace,
java.util.Collection<Range<Token>> streamedRanges) |
static void |
SystemKeyspace.updateViewBuildStatus(java.lang.String ksname,
java.lang.String viewName,
Range<Token> range,
Token lastToken,
long keysBuilt) |
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 | Field and Description |
---|---|
java.util.function.Function<java.lang.String,? extends java.util.Collection<Range<Token>>> |
Verifier.Options.tokenLookup |
Modifier and Type | Method and Description |
---|---|
void |
CompactionManager.forceCompactionForTokenRange(ColumnFamilyStore cfStore,
java.util.Collection<Range<Token>> ranges)
Forces a major compaction of specified token ranges of the specified column family.
|
abstract java.util.List<ISSTableScanner> |
AbstractStrategyHolder.getScanners(AbstractStrategyHolder.GroupedSSTableContainer sstables,
java.util.Collection<Range<Token>> ranges) |
java.util.List<ISSTableScanner> |
CompactionStrategyHolder.getScanners(AbstractStrategyHolder.GroupedSSTableContainer sstables,
java.util.Collection<Range<Token>> ranges) |
java.util.List<ISSTableScanner> |
PendingRepairHolder.getScanners(AbstractStrategyHolder.GroupedSSTableContainer sstables,
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) |
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) |
AbstractCompactionStrategy.ScannerList |
CompactionStrategyManager.maybeGetScanners(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
|
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.
|
Verifier.Options.Builder |
Verifier.Options.Builder.tokenLookup(java.util.function.Function<java.lang.String,? extends java.util.Collection<Range<Token>>> tokenLookup) |
Constructor and Description |
---|
RangeOwnHelper(java.util.List<Range<Token>> normalizedRanges) |
Modifier and Type | Method and Description |
---|---|
java.util.Map<Range<Token>,java.lang.Long> |
CassandraValidationIterator.getRangePartitionCounts() |
Modifier and Type | Method and Description |
---|---|
protected PendingAntiCompaction.AcquisitionCallable |
PendingAntiCompaction.getAcquisitionCallable(ColumnFamilyStore cfs,
java.util.Set<Range<Token>> ranges,
java.util.UUID prsId,
int acquireRetrySeconds,
int acquireSleepMillis) |
ValidationPartitionIterator |
CassandraTableRepairManager.getValidationIterator(java.util.Collection<Range<Token>> ranges,
java.util.UUID parentId,
java.util.UUID sessionID,
boolean isIncremental,
int nowInSec) |
void |
CassandraTableRepairManager.snapshot(java.lang.String name,
java.util.Collection<Range<Token>> ranges,
boolean force) |
Constructor and Description |
---|
AcquisitionCallable(ColumnFamilyStore cfs,
java.util.Collection<Range<Token>> ranges,
java.util.UUID sessionID,
int acquireRetrySeconds,
int acquireSleepMillis) |
CassandraValidationIterator(ColumnFamilyStore cfs,
java.util.Collection<Range<Token>> ranges,
java.util.UUID parentId,
java.util.UUID sessionID,
boolean isIncremental,
int nowInSec) |
Constructor and Description |
---|
CassandraOutgoingFile(StreamOperation operation,
Ref<SSTableReader> ref,
java.util.List<SSTableReader.PartitionPositionBounds> sections,
java.util.List<Range<Token>> normalizedRanges,
long estimatedKeys) |
Modifier and Type | Method and Description |
---|---|
static java.util.Optional<Replica> |
ViewUtils.getViewNaturalEndpoint(AbstractReplicationStrategy replicationStrategy,
Token baseToken,
Token viewToken)
Calculate the natural endpoint for the view.
|
Constructor and Description |
---|
ViewBuilderTask(ColumnFamilyStore baseCfs,
View view,
Range<Token> range,
Token lastToken,
long keysBuilt) |
Constructor and Description |
---|
ViewBuilderTask(ColumnFamilyStore baseCfs,
View view,
Range<Token> range,
Token lastToken,
long keysBuilt) |
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) |
Token |
Token.TokenFactory.fromByteBuffer(java.nio.ByteBuffer bytes,
int position,
int length) |
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 |
Splitter.WeightedRange.left() |
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 |
Splitter.WeightedRange.right() |
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) |
static java.util.Collection<Token> |
BootStrapper.getBootstrapTokens(TokenMetadata metadata,
InetAddressAndPort address,
long schemaWaitDelay)
if initialtoken was specified, use that (split on comma).
|
static java.util.Collection<Token> |
BootStrapper.getRandomTokens(TokenMetadata metadata,
int numTokens) |
com.google.common.collect.Multimap<InetAddressAndPort,Range<Token>> |
RangeFetchMapCalculator.getRangeFetchMap() |
Range<Token> |
Splitter.WeightedRange.range() |
java.util.Set<Range<Token>> |
Splitter.split(java.util.Collection<Range<Token>> ranges,
int parts)
Splits the specified token ranges in at least
parts subranges. |
java.util.List<Token> |
Splitter.splitOwnedRanges(int parts,
java.util.List<Splitter.WeightedRange> weightedRanges,
boolean dontSplitRanges) |
Modifier and Type | Method and Description |
---|---|
int |
Token.TokenFactory.byteSize(Token token) |
int |
ByteOrderedPartitioner.BytesToken.compareTo(Token other) |
int |
LocalPartitioner.LocalToken.compareTo(Token o) |
int |
Murmur3Partitioner.LongToken.compareTo(Token o) |
protected java.math.BigInteger |
Splitter.elapsedTokens(Token token,
Range<Token> range)
Computes the number of elapsed tokens from the range start until this token
|
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) |
double |
Splitter.positionInRange(Token token,
Range<Token> range)
Computes the normalized position of this token relative to this range
|
void |
Token.TokenFactory.serialize(Token token,
java.nio.ByteBuffer out) |
void |
Token.TokenFactory.serialize(Token token,
DataOutputPlus out) |
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) |
boolean |
Range.OrderedRangeContainmentChecker.test(Token t)
Returns true if the ranges given in the constructor contains the token, false otherwise.
|
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 |
---|---|
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) |
protected java.math.BigInteger |
Splitter.elapsedTokens(Token token,
Range<Token> range)
Computes the number of elapsed tokens from the range start until this token
|
static boolean |
Range.intersects(java.lang.Iterable<Range<Token>> l,
java.lang.Iterable<Range<Token>> r) |
static boolean |
Range.intersects(java.lang.Iterable<Range<Token>> l,
java.lang.Iterable<Range<Token>> r) |
static Range<PartitionPosition> |
Range.makeRowRange(Range<Token> tokenBounds) |
double |
Splitter.positionInRange(Token token,
Range<Token> range)
Computes the normalized position of this token relative to this range
|
java.util.Set<Range<Token>> |
Splitter.split(java.util.Collection<Range<Token>> ranges,
int parts)
Splits the specified token ranges in at least
parts subranges. |
protected java.math.BigInteger |
Splitter.tokensInRange(Range<Token> range) |
Constructor and Description |
---|
BootStrapper(InetAddressAndPort address,
java.util.Collection<Token> tokens,
TokenMetadata tmd) |
OrderedRangeContainmentChecker(java.util.Collection<Range<Token>> ranges) |
RangeStreamer(TokenMetadata metadata,
java.util.Collection<Token> tokens,
InetAddressAndPort address,
StreamOperation streamOperation,
boolean useStrictConsistency,
IEndpointSnitch snitch,
StreamStateStore stateStore,
boolean connectSequentially,
int connectionsPerHost) |
WeightedRange(double weight,
Range<Token> range) |
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,
InetAddressAndPort endpoint,
int numTokens) |
static java.util.Collection<Token> |
TokenAllocation.allocateTokens(TokenMetadata tokenMetadata,
int replicas,
InetAddressAndPort endpoint,
int numTokens) |
java.util.Collection<Token> |
OfflineTokenAllocator.FakeNode.tokens() |
Modifier and Type | Method and Description |
---|---|
static TokenAllocator<InetAddressAndPort> |
TokenAllocatorFactory.createTokenAllocator(java.util.NavigableMap<Token,InetAddressAndPort> sortedTokens,
org.apache.cassandra.dht.tokenallocator.ReplicationStrategy<InetAddressAndPort> strategy,
IPartitioner partitioner) |
Constructor and Description |
---|
FakeNode(InetAddressAndPort address,
java.lang.Integer rackId,
java.util.Collection<Token> tokens) |
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 |
---|---|
AbstractBounds<Token> |
SSTable.getBounds() |
java.util.Map<InetAddressAndPort,java.util.Collection<Range<Token>>> |
SSTableLoader.Client.getEndpointToRangesMap() |
Modifier and Type | Method and Description |
---|---|
protected void |
SSTableLoader.Client.addRangeForEndpoint(Range<Token> range,
InetAddressAndPort endpoint) |
protected java.util.Collection<SSTableReader> |
SSTableLoader.openSSTables(java.util.Map<InetAddressAndPort,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<SSTableReader.PartitionPositionBounds> |
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)
Direct I/O SSTableScanner over a defined collection of ranges of tokens.
|
ISSTableScanner |
SSTableReader.getScanner(Range<Token> range)
Direct I/O SSTableScanner over a defined range of tokens.
|
boolean |
SSTableReader.intersects(java.util.Collection<Range<Token>> ranges) |
Modifier and Type | Method and Description |
---|---|
ISSTableScanner |
BigTableReader.getScanner(java.util.Collection<Range<Token>> ranges)
Direct I/O SSTableScanner over a defined collection of ranges of tokens.
|
static ISSTableScanner |
BigTableScanner.getScanner(SSTableReader sstable,
java.util.Collection<Range<Token>> tokenRanges) |
Modifier and Type | Field and Description |
---|---|
static Range<Token> |
SystemReplicas.FULL_RANGE |
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(InetAddressAndPort endpoint)
Deprecated.
|
Token |
EndpointsForToken.token() |
Token |
ReplicaLayout.ForTokenRead.token() |
Token |
ReplicaLayout.ForTokenWrite.token() |
Token |
ReplicaLayout.ForToken.token() |
Modifier and Type | Method and Description |
---|---|
java.util.Map<Range<Token>,Replica> |
RangesAtEndpoint.byRange() |
BiMultiValMap<Token,InetAddressAndPort> |
TokenMetadata.getBootstrapTokens() |
com.google.common.collect.Multimap<InetAddressAndPort,Token> |
TokenMetadata.getEndpointToTokenMapForReading() |
java.util.Set<Pair<Token,InetAddressAndPort>> |
TokenMetadata.getMovingEndpoints()
Endpoints which are migrating to the new tokens
|
java.util.Map<Token,InetAddressAndPort> |
TokenMetadata.getNormalAndBootstrappingTokenToEndpointMap() |
Range<Token> |
TokenMetadata.getPrimaryRangeFor(Token right)
Deprecated.
|
java.util.Collection<Range<Token>> |
TokenMetadata.getPrimaryRangesFor(java.util.Collection<Token> tokens) |
java.util.Collection<Token> |
TokenMetadata.getTokens(InetAddressAndPort endpoint) |
java.util.Iterator<java.util.Map.Entry<Range<Token>,EndpointsForRange.Builder>> |
PendingRangeMaps.iterator() |
Range<Token> |
EndpointsForRange.range() |
Range<Token> |
Replica.range() |
java.util.Set<Range<Token>> |
RangesAtEndpoint.ranges() |
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,
InetAddressAndPort endpoint)
Deprecated.
|
void |
TokenMetadata.addMovingEndpoint(Token token,
InetAddressAndPort endpoint)
Add a new moving endpoint
|
static EndpointsForToken.Builder |
EndpointsForToken.builder(Token token) |
static EndpointsForToken.Builder |
EndpointsForToken.builder(Token token,
int capacity) |
abstract EndpointsForRange |
AbstractReplicationStrategy.calculateNaturalReplicas(Token searchToken,
TokenMetadata tokenMetadata)
Calculate the natural endpoints for the given token.
|
EndpointsForRange |
LocalStrategy.calculateNaturalReplicas(Token token,
TokenMetadata metadata) |
EndpointsForRange |
NetworkTopologyStrategy.calculateNaturalReplicas(Token searchToken,
TokenMetadata tokenMetadata)
calculate endpoints in one pass through the tokens by tracking our progress in each DC.
|
EndpointsForRange |
SimpleStrategy.calculateNaturalReplicas(Token token,
TokenMetadata metadata) |
static EndpointsForToken |
EndpointsForToken.copyOf(Token token,
java.util.Collection<Replica> replicas) |
static EndpointsForToken |
EndpointsForToken.empty(Token token) |
static Token |
TokenMetadata.firstToken(java.util.ArrayList<Token> ring,
Token start) |
static int |
TokenMetadata.firstTokenIndex(java.util.ArrayList<Token> ring,
Token start,
boolean insertMin) |
static ReplicaPlan.ForTokenWrite |
ReplicaPlans.forForwardingCounterWrite(Keyspace keyspace,
Token token,
Replica replica)
A forwarding counter write is always sent to a single owning coordinator for the range, by the original coordinator
(if it is not itself an owner)
|
static ReplicaPlan.ForTokenRead |
ReplicaPlans.forRead(Keyspace keyspace,
Token token,
ConsistencyLevel consistencyLevel,
SpeculativeRetryPolicy retry)
Construct a plan for reading the provided token at the provided consistency level.
|
static ReplicaPlan.ForTokenWrite |
ReplicaPlans.forReadRepair(Token token,
ReplicaPlan.ForRead<?> readPlan) |
static ReplicaPlan.ForTokenRead |
ReplicaPlans.forSingleReplicaRead(Keyspace keyspace,
Token token,
Replica replica)
Construct a plan for reading from a single node - this permits no speculation or read-repair
|
static ReplicaPlan.ForTokenWrite |
ReplicaPlans.forSingleReplicaWrite(Keyspace keyspace,
Token token,
Replica replica)
Construct a ReplicaPlan for writing to exactly one node, with CL.ONE.
|
EndpointsForToken |
EndpointsForRange.forToken(Token token) |
static ReplicaLayout.ForTokenWrite |
ReplicaLayout.forTokenWriteLiveAndDown(Keyspace keyspace,
Token token)
Gets the 'natural' and 'pending' replicas that own a given token, with no filtering or processing.
|
static ReplicaPlan.ForTokenWrite |
ReplicaPlans.forWrite(Keyspace keyspace,
ConsistencyLevel consistencyLevel,
Token token,
ReplicaPlans.Selector selector) |
static Replica |
Replica.fullReplica(InetAddressAndPort endpoint,
Token start,
Token end) |
EndpointsForRange |
AbstractReplicationStrategy.getCachedReplicas(long ringVersion,
Token t) |
InetAddressAndPort |
TokenMetadata.getEndpoint(Token token) |
RangesAtEndpoint |
AbstractReplicationStrategy.getPendingAddressRanges(TokenMetadata metadata,
Token pendingToken,
InetAddressAndPort pendingAddress) |
Token |
TokenMetadata.getPredecessor(Token token) |
Range<Token> |
TokenMetadata.getPrimaryRangeFor(Token right)
Deprecated.
|
Token |
TokenMetadata.getSuccessor(Token token) |
EndpointsForToken |
TokenMetadata.getWriteEndpoints(Token token,
java.lang.String keyspaceName,
EndpointsForToken natural)
Deprecated.
retained for benefit of old tests
|
static EndpointsForToken |
EndpointsForToken.of(Token token,
Replica... replicas) |
static EndpointsForToken |
EndpointsForToken.of(Token token,
Replica replica) |
EndpointsForToken |
PendingRangeMaps.pendingEndpointsFor(Token token) |
EndpointsForToken |
TokenMetadata.pendingEndpointsForToken(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)
|
static Replica |
Replica.transientReplica(InetAddressAndPort endpoint,
Token start,
Token end) |
void |
TokenMetadata.updateNormalToken(Token token,
InetAddressAndPort 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,
InetAddressAndPort endpoint) |
void |
PendingRangeMaps.addPendingRange(Range<Token> range,
Replica replica) |
void |
TokenMetadata.addReplaceTokens(java.util.Collection<Token> replacingTokens,
InetAddressAndPort newNode,
InetAddressAndPort oldNode) |
static EndpointsForRange.Builder |
EndpointsForRange.builder(Range<Token> range) |
static EndpointsForRange.Builder |
EndpointsForRange.builder(Range<Token> range,
int capacity) |
boolean |
Replica.contains(Range<Token> that) |
boolean |
RangesAtEndpoint.contains(Range<Token> range,
boolean isFull) |
Replica |
Replica.decorateSubrange(Range<Token> subrange) |
static EndpointsForRange |
EndpointsForRange.empty(Range<Token> range) |
static Token |
TokenMetadata.firstToken(java.util.ArrayList<Token> ring,
Token start) |
static int |
TokenMetadata.firstTokenIndex(java.util.ArrayList<Token> ring,
Token start,
boolean insertMin) |
static Replica |
Replica.fullReplica(InetAddressAndPort endpoint,
Range<Token> range) |
EndpointsForRange |
EndpointsByRange.get(Range<Token> range) |
RangesAtEndpoint |
AbstractReplicationStrategy.getPendingAddressRanges(TokenMetadata metadata,
java.util.Collection<Token> pendingTokens,
InetAddressAndPort pendingAddress) |
java.util.Collection<Range<Token>> |
TokenMetadata.getPrimaryRangesFor(java.util.Collection<Token> tokens) |
protected EndpointsForRange.Builder |
EndpointsByRange.Builder.newBuilder(Range<Token> range) |
void |
EndpointsByRange.Builder.putAll(Range<Token> range,
EndpointsForRange replicas,
ReplicaCollection.Builder.Conflict ignoreConflicts) |
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)
|
RangesAtEndpoint |
Replica.subtractIgnoreTransientStatus(Range<Token> subtract)
Don't use this method and ignore transient status unless you are explicitly handling it outside this method.
|
static RangesAtEndpoint |
RangesAtEndpoint.toDummyList(java.util.Collection<Range<Token>> ranges)
Use of this method to synthesize Replicas is almost always wrong.
|
static Replica |
Replica.transientReplica(InetAddressAndPort endpoint,
Range<Token> range) |
void |
TokenMetadata.updateNormalTokens(java.util.Collection<Token> tokens,
InetAddressAndPort endpoint) |
void |
TokenMetadata.updateNormalTokens(com.google.common.collect.Multimap<InetAddressAndPort,Token> endpointTokens)
Update token map with a set of token/endpoint pairs in normal state.
|
Constructor and Description |
---|
Builder(Token token) |
Builder(Token token,
int capacity) |
Replica(InetAddressAndPort endpoint,
Token start,
Token end,
boolean full) |
Constructor and Description |
---|
Builder(Range<Token> range) |
Builder(Range<Token> range,
int capacity) |
EndpointsByRange(java.util.Map<Range<Token>,EndpointsForRange> map) |
Replica(InetAddressAndPort endpoint,
Range<Token> range,
boolean full) |
Modifier and Type | Field and Description |
---|---|
java.util.Collection<Range<Token>> |
CommonRange.ranges |
java.util.Collection<Range<Token>> |
RepairJobDesc.ranges
repairing range
|
java.util.Collection<Range<Token>> |
RepairSessionResult.ranges |
java.util.List<Range<Token>> |
SyncTask.rangesToSync |
Modifier and Type | Method and Description |
---|---|
abstract java.util.Map<Range<Token>,java.lang.Long> |
ValidationPartitionIterator.getRangePartitionCounts() |
java.util.Collection<Range<Token>> |
RepairSession.ranges() |
Modifier and Type | Method and Description |
---|---|
boolean |
Validator.findCorrectRange(Token t) |
Modifier and Type | Method and Description |
---|---|
ValidationPartitionIterator |
TableRepairManager.getValidationIterator(java.util.Collection<Range<Token>> ranges,
java.util.UUID parentId,
java.util.UUID sessionID,
boolean isIncremental,
int nowInSec)
Return a validation iterator for the given parameters.
|
void |
TableRepairManager.snapshot(java.lang.String name,
java.util.Collection<Range<Token>> ranges,
boolean force)
For snapshot repairs.
|
static void |
SystemDistributedKeyspace.successfulParentRepair(java.util.UUID parent_id,
java.util.Collection<Range<Token>> successfulRanges) |
Constructor and Description |
---|
AsymmetricRemoteSyncTask(RepairJobDesc desc,
InetAddressAndPort to,
InetAddressAndPort from,
java.util.List<Range<Token>> differences,
PreviewKind previewKind) |
CommonRange(java.util.Set<InetAddressAndPort> endpoints,
java.util.Set<InetAddressAndPort> transEndpoints,
java.util.Collection<Range<Token>> ranges) |
CommonRange(java.util.Set<InetAddressAndPort> endpoints,
java.util.Set<InetAddressAndPort> transEndpoints,
java.util.Collection<Range<Token>> ranges,
boolean hasSkippedReplicas) |
LocalSyncTask(RepairJobDesc desc,
InetAddressAndPort local,
InetAddressAndPort remote,
java.util.List<Range<Token>> diff,
java.util.UUID pendingRepair,
boolean requestRanges,
boolean transferRanges,
PreviewKind previewKind) |
RepairJobDesc(java.util.UUID parentSessionId,
java.util.UUID sessionId,
java.lang.String keyspace,
java.lang.String columnFamily,
java.util.Collection<Range<Token>> ranges) |
RepairSessionResult(java.util.UUID sessionId,
java.lang.String keyspace,
java.util.Collection<Range<Token>> ranges,
java.util.Collection<RepairResult> repairJobResults,
boolean skippedReplicas) |
StreamingRepairTask(RepairJobDesc desc,
InetAddressAndPort initiator,
InetAddressAndPort src,
InetAddressAndPort dst,
java.util.Collection<Range<Token>> ranges,
java.util.UUID pendingRepair,
PreviewKind previewKind,
boolean asymmetric) |
SymmetricRemoteSyncTask(RepairJobDesc desc,
InetAddressAndPort r1,
InetAddressAndPort r2,
java.util.List<Range<Token>> differences,
PreviewKind previewKind) |
SyncTask(RepairJobDesc desc,
InetAddressAndPort primaryEndpoint,
InetAddressAndPort peer,
java.util.List<Range<Token>> rangesToSync,
PreviewKind previewKind) |
Modifier and Type | Method and Description |
---|---|
static java.util.Set<Range<Token>> |
RangeDenormalizer.denormalize(Range<Token> range,
RangeMap<StreamFromOptions> incoming)
"Denormalizes" (kind of the opposite of what Range.normalize does) the ranges in the keys of {{incoming}}
It makes sure that if there is an intersection between {{range}} and some of the ranges in {{incoming.keySet()}}
we know that all intersections are keys in the updated {{incoming}}
|
java.util.Set<java.util.Map.Entry<Range<Token>,T>> |
RangeMap.entrySet() |
java.util.NavigableSet<Range<Token>> |
HostDifferences.get(InetAddressAndPort differingHost) |
com.google.common.collect.ImmutableMap<Range<Token>,StreamFromOptions> |
IncomingRepairStreamTracker.getIncoming() |
java.util.Set<Range<Token>> |
RangeMap.keySet() |
java.util.Set<java.util.Map.Entry<Range<Token>,T>> |
RangeMap.removeIntersecting(Range<Token> range) |
static java.util.Set<Range<Token>> |
RangeDenormalizer.subtractAll(java.util.Collection<java.util.Map.Entry<Range<Token>,StreamFromOptions>> ranges,
Range<Token> toSubtract)
copied from Range - need to iterate over the map entries
|
Modifier and Type | Method and Description |
---|---|
void |
HostDifferences.add(InetAddressAndPort endpoint,
java.util.Collection<Range<Token>> difference)
Adds a set of differences between the node this instance is tracking and endpoint
|
void |
IncomingRepairStreamTracker.addIncomingRangeFrom(Range<Token> range,
InetAddressAndPort streamFromNode)
Adds a range to be streamed from streamFromNode
First the currently tracked ranges are denormalized to make sure that no ranges overlap, then
the streamFromNode is added to the StreamFromOptions for the range
|
void |
HostDifferences.addSingleRange(InetAddressAndPort remoteNode,
Range<Token> rangeToFetch) |
StreamFromOptions |
StreamFromOptions.copy(Range<Token> withRange) |
static java.util.Set<Range<Token>> |
RangeDenormalizer.denormalize(Range<Token> range,
RangeMap<StreamFromOptions> incoming)
"Denormalizes" (kind of the opposite of what Range.normalize does) the ranges in the keys of {{incoming}}
It makes sure that if there is an intersection between {{range}} and some of the ranges in {{incoming.keySet()}}
we know that all intersections are keys in the updated {{incoming}}
|
boolean |
DifferenceHolder.hasDifferenceBetween(InetAddressAndPort node1,
InetAddressAndPort node2,
Range<Token> range) |
boolean |
HostDifferences.hasDifferencesFor(InetAddressAndPort node2,
Range<Token> range)
Does this instance have differences for range with node2?
|
T |
RangeMap.put(Range<Token> key,
T value) |
void |
RangeMap.putAll(java.util.Map<? extends Range<Token>,? extends T> m) |
java.util.Set<java.util.Map.Entry<Range<Token>,T>> |
RangeMap.removeIntersecting(Range<Token> range) |
static java.util.Set<Range<Token>> |
RangeDenormalizer.subtractAll(java.util.Collection<java.util.Map.Entry<Range<Token>,StreamFromOptions>> ranges,
Range<Token> toSubtract)
copied from Range - need to iterate over the map entries
|
static java.util.Set<Range<Token>> |
RangeDenormalizer.subtractAll(java.util.Collection<java.util.Map.Entry<Range<Token>,StreamFromOptions>> ranges,
Range<Token> toSubtract)
copied from Range - need to iterate over the map entries
|
Constructor and Description |
---|
StreamFromOptions(DifferenceHolder differences,
Range<Token> range) |
Modifier and Type | Field and Description |
---|---|
Range<Token> |
RepairedState.Section.range |
com.google.common.collect.ImmutableSet<Range<Token>> |
ConsistentSession.ranges |
Modifier and Type | Method and Description |
---|---|
void |
RepairedState.add(java.util.Collection<Range<Token>> ranges,
long repairedAt) |
CleanupSummary |
LocalSessions.cleanup(TableId tid,
java.util.Collection<Range<Token>> ranges,
boolean force) |
PendingStats |
LocalSessions.getPendingStats(TableId tid,
java.util.Collection<Range<Token>> ranges) |
RepairedState.Stats |
RepairedState.getRepairedStats(java.util.Collection<Range<Token>> ranges) |
RepairedState.Stats |
LocalSessions.getRepairedStats(TableId tid,
java.util.Collection<Range<Token>> ranges) |
boolean |
ConsistentSession.intersects(java.lang.Iterable<Range<Token>> otherRanges) |
long |
RepairedState.minRepairedAt(java.util.Collection<Range<Token>> ranges) |
java.util.List<java.util.Map<java.lang.String,java.lang.String>> |
LocalSessions.sessionInfo(boolean all,
java.util.Set<Range<Token>> ranges) |
Modifier and Type | Field and Description |
---|---|
java.util.Collection<Range<Token>> |
PrepareMessage.ranges |
java.util.Collection<Range<Token>> |
SyncRequest.ranges |
Modifier and Type | Method and Description |
---|---|
java.util.Collection<Range<Token>> |
RepairOption.getRanges() |
static java.util.Set<Range<Token>> |
RepairOption.parseRanges(java.lang.String rangesStr,
IPartitioner partitioner) |
Constructor and Description |
---|
PrepareMessage(java.util.UUID parentRepairSession,
java.util.List<TableId> tableIds,
java.util.Collection<Range<Token>> ranges,
boolean isIncremental,
long timestamp,
boolean isGlobal,
PreviewKind previewKind) |
RepairOption(RepairParallelism parallelism,
boolean primaryRange,
boolean incremental,
boolean trace,
int jobThreads,
java.util.Collection<Range<Token>> ranges,
boolean isSubrangeRepair,
boolean pullRepair,
boolean forceRepair,
PreviewKind previewKind,
boolean optimiseStreams,
boolean ignoreUnreplicatedKeyspaces) |
SyncRequest(RepairJobDesc desc,
InetAddressAndPort initiator,
InetAddressAndPort src,
InetAddressAndPort dst,
java.util.Collection<Range<Token>> ranges,
PreviewKind previewKind,
boolean asymmetric) |
Modifier and Type | Field and Description |
---|---|
Range<Token> |
TokenRange.range |
Modifier and Type | Method and Description |
---|---|
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.List<Range<Token>> |
StorageService.getLocalAndPendingRanges(java.lang.String ks) |
java.util.Collection<Range<Token>> |
StorageService.getLocalPrimaryRange() |
java.util.Collection<Range<Token>> |
StorageService.getLocalPrimaryRangeForEndpoint(InetAddressAndPort referenceEndpoint) |
java.util.Collection<Token> |
StorageService.getLocalTokens() |
java.util.Collection<Range<Token>> |
StorageService.getPrimaryRangeForEndpointWithinDC(java.lang.String keyspace,
InetAddressAndPort 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,
InetAddressAndPort ep)
Get the "primary ranges" for the specified keyspace and endpoint.
|
java.util.Collection<Range<Token>> |
StorageService.getPrimaryRangesWithinDC(java.lang.String keyspace) |
java.util.Set<Range<Token>> |
ActiveRepairService.ParentRepairSession.getRanges() |
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 |
---|---|
boolean |
StorageService.bootstrap(java.util.Collection<Token> tokens,
long bootstrapTimeoutMillis)
Bootstrap node by fetching data from other nodes.
|
static TokenRange |
TokenRange.create(Token.TokenFactory tokenFactory,
Range<Token> range,
java.util.List<InetAddressAndPort> endpoints,
boolean withPorts) |
void |
StorageService.finishJoiningRing(boolean didBootstrap,
java.util.Collection<Token> tokens) |
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 EndpointsForRange |
ActiveRepairService.getNeighbors(java.lang.String keyspaceName,
java.lang.Iterable<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 EndpointsForRange |
ActiveRepairService.getNeighbors(java.lang.String keyspaceName,
java.lang.Iterable<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,
InetAddressAndPort coordinator,
java.util.List<ColumnFamilyStore> columnFamilyStores,
java.util.Collection<Range<Token>> ranges,
boolean isIncremental,
long repairedAt,
boolean isGlobal,
PreviewKind previewKind) |
void |
StorageService.setGossipTokens(java.util.Collection<Token> tokens) |
void |
StorageService.setTokens(java.util.Collection<Token> tokens)
This method updates the local token on disk
|
java.util.concurrent.Future<StreamState> |
StorageService.startBootstrap(java.util.Collection<Token> tokens) |
Constructor and Description |
---|
ParentRepairSession(InetAddressAndPort coordinator,
java.util.List<ColumnFamilyStore> columnFamilyStores,
java.util.Collection<Range<Token>> ranges,
boolean isIncremental,
long repairedAt,
boolean isGlobal,
PreviewKind previewKind) |
Modifier and Type | Field and Description |
---|---|
java.util.Map<java.lang.String,java.util.Set<Range<Token>>> |
StreamEvent.SessionCompleteEvent.transferredRangesPerKeyspace |
Modifier and Type | Field and Description |
---|---|
Token |
MerkleTree.RowHash.token |
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 |
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[] |
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) |
Constructor and Description |
---|
MerkleTree(IPartitioner partitioner,
Range<Token> range,
int hashdepth,
long maxsize) |
Copyright © 2009-2022 The Apache Software Foundation