Modifier and Type | Field and Description |
---|---|
TimeUUID |
Batch.id |
Modifier and Type | Method and Description |
---|---|
static Batch |
Batch.createLocal(TimeUUID id,
long creationTime,
java.util.Collection<Mutation> mutations)
Creates a 'local' batch - with all enclosed mutations in decoded form (as Mutation instances)
|
static Batch |
Batch.createRemote(TimeUUID id,
long creationTime,
java.util.Collection<java.nio.ByteBuffer> mutations)
Creates a 'remote' batch - with all enclosed mutations in encoded form (as ByteBuffer instances)
The mutations will always be encoded using the current messaging version.
|
static void |
BatchlogManager.remove(TimeUUID id) |
Modifier and Type | Method and Description |
---|---|
void |
BatchRemoveVerbHandler.doVerb(Message<TimeUUID> message) |
Modifier and Type | Method and Description |
---|---|
TimeUUID |
UntypedResultSet.Row.getTimeUUID(java.lang.String column) |
Modifier and Type | Method and Description |
---|---|
java.util.Map<TimeUUID,PendingStat> |
ColumnFamilyStore.getPendingRepairStats() |
Modifier and Type | Method and Description |
---|---|
SSTableMultiWriter |
ColumnFamilyStore.createSSTableMultiWriter(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
int sstableLevel,
SerializationHeader header,
LifecycleNewTracker lifecycleNewTracker) |
SSTableMultiWriter |
ColumnFamilyStore.createSSTableMultiWriter(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
MetadataCollector metadataCollector,
SerializationHeader header,
LifecycleNewTracker lifecycleNewTracker) |
static void |
SystemKeyspace.updateHintsDropped(InetAddressAndPort ep,
TimeUUID timePeriod,
int value) |
void |
ColumnFamilyStore.writeAndAddMemtableRanges(TimeUUID repairSessionID,
java.util.function.Supplier<java.util.Collection<Range<PartitionPosition>>> rangesSupplier,
Refs<SSTableReader> placeIntoRefs) |
Modifier and Type | Method and Description |
---|---|
CleanupSummary |
ColumnFamilyStore.releaseRepairData(java.util.Collection<TimeUUID> sessions,
boolean force)
promotes (or demotes) data attached to an incremental repair session that has either completed successfully,
or failed
|
Modifier and Type | Method and Description |
---|---|
static TimeUUID |
CompactionTask.getPendingRepair(java.util.Set<SSTableReader> sstables) |
TimeUUID |
CompactionInfo.getTaskId() |
Modifier and Type | Method and Description |
---|---|
SSTableMultiWriter |
AbstractCompactionStrategy.createSSTableMultiWriter(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
MetadataCollector meta,
SerializationHeader header,
java.util.Collection<Index> indexes,
LifecycleNewTracker lifecycleNewTracker) |
abstract SSTableMultiWriter |
AbstractStrategyHolder.createSSTableMultiWriter(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
MetadataCollector collector,
SerializationHeader header,
java.util.Collection<Index> indexes,
LifecycleNewTracker lifecycleNewTracker) |
SSTableMultiWriter |
CompactionStrategyHolder.createSSTableMultiWriter(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
MetadataCollector collector,
SerializationHeader header,
java.util.Collection<Index> indexes,
LifecycleNewTracker lifecycleNewTracker) |
SSTableMultiWriter |
CompactionStrategyManager.createSSTableMultiWriter(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
MetadataCollector collector,
SerializationHeader header,
java.util.Collection<Index> indexes,
LifecycleNewTracker lifecycleNewTracker) |
SSTableMultiWriter |
PendingRepairHolder.createSSTableMultiWriter(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
MetadataCollector collector,
SerializationHeader header,
java.util.Collection<Index> indexes,
LifecycleNewTracker lifecycleNewTracker) |
static SSTableWriter |
CompactionManager.createWriter(ColumnFamilyStore cfs,
File compactionFileLocation,
long expectedBloomFilterSize,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
SSTableReader sstable,
LifecycleTransaction txn) |
static SSTableWriter |
CompactionManager.createWriterForAntiCompaction(ColumnFamilyStore cfs,
File compactionFileLocation,
int expectedBloomFilterSize,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
java.util.Collection<SSTableReader> sstables,
ILifecycleTransaction txn) |
static CompactionIterator |
CompactionManager.getAntiCompactionIterator(java.util.List<ISSTableScanner> scanners,
CompactionController controller,
int nowInSec,
TimeUUID timeUUID,
ActiveCompactionsTracker activeCompactions,
java.util.function.BooleanSupplier isCancelled) |
boolean |
CompactionStrategyManager.hasDataForPendingRepair(TimeUUID sessionID) |
boolean |
PendingRepairHolder.hasDataForSession(TimeUUID sessionID) |
void |
CompactionStrategyManager.mutateRepaired(java.util.Collection<SSTableReader> sstables,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient)
Mutates sstable repairedAt times and notifies listeners of the change with the writeLock held.
|
void |
CompactionManager.performAnticompaction(ColumnFamilyStore cfs,
RangesAtEndpoint replicas,
Refs<SSTableReader> validatedForRepair,
LifecycleTransaction txn,
TimeUUID sessionID,
java.util.function.BooleanSupplier isCancelled)
Make sure the {validatedForRepair} are marked for compaction before calling this.
|
Future<java.lang.Void> |
CompactionManager.submitPendingAntiCompaction(ColumnFamilyStore cfs,
RangesAtEndpoint tokenRanges,
Refs<SSTableReader> sstables,
LifecycleTransaction txn,
TimeUUID sessionId,
java.util.function.BooleanSupplier isCancelled)
Splits the given token ranges of the given sstables into a pending repair silo
|
static CompactionInfo |
CompactionInfo.withoutSSTables(TableMetadata metadata,
OperationType tasktype,
long completed,
long total,
CompactionInfo.Unit unit,
TimeUUID compactionId)
Special compaction info where we always need to cancel the compaction - for example ViewBuilderTask and AutoSavingCache where we don't know
the sstables at construction
|
Modifier and Type | Method and Description |
---|---|
CleanupSummary |
CompactionStrategyManager.releaseRepairData(java.util.Collection<TimeUUID> sessions) |
Constructor and Description |
---|
CompactionInfo(TableMetadata metadata,
OperationType tasktype,
long bytesComplete,
long totalBytes,
TimeUUID compactionId,
java.util.Collection<SSTableReader> sstables) |
CompactionIterator(OperationType type,
java.util.List<ISSTableScanner> scanners,
AbstractCompactionController controller,
int nowInSec,
TimeUUID compactionId) |
CompactionIterator(OperationType type,
java.util.List<ISSTableScanner> scanners,
AbstractCompactionController controller,
int nowInSec,
TimeUUID compactionId,
ActiveCompactionsTracker activeCompactions,
TopPartitionTracker.Collector topPartitionCollector) |
Modifier and Type | Field and Description |
---|---|
protected TimeUUID |
CompactionAwareWriter.pendingRepair |
Modifier and Type | Method and Description |
---|---|
TimeUUID |
LifecycleTransaction.opId() |
Modifier and Type | Method and Description |
---|---|
TimeUUID |
ByteArrayAccessor.toTimeUUID(byte[] value) |
TimeUUID |
ByteBufferAccessor.toTimeUUID(java.nio.ByteBuffer value) |
TimeUUID |
ValueAccessor.toTimeUUID(V value)
returns a TimeUUID from offset 0
|
Modifier and Type | Method and Description |
---|---|
TypeSerializer<TimeUUID> |
TimeUUIDType.getSerializer() |
AbstractType<TimeUUID> |
ListType.nameComparator() |
Modifier and Type | Method and Description |
---|---|
protected PendingAntiCompaction.AcquisitionCallable |
PendingAntiCompaction.getAcquisitionCallable(ColumnFamilyStore cfs,
java.util.Set<Range<Token>> ranges,
TimeUUID prsId,
int acquireRetrySeconds,
int acquireSleepMillis) |
protected org.apache.cassandra.db.repair.PendingAntiCompaction.AcquisitionCallback |
PendingAntiCompaction.getAcquisitionCallback(TimeUUID prsId,
RangesAtEndpoint tokenRanges) |
static Refs<SSTableReader> |
CassandraValidationIterator.getSSTablesToValidate(ColumnFamilyStore cfs,
java.util.Collection<Range<Token>> ranges,
TimeUUID parentId,
boolean isIncremental) |
ValidationPartitionIterator |
CassandraTableRepairManager.getValidationIterator(java.util.Collection<Range<Token>> ranges,
TimeUUID parentId,
TimeUUID sessionID,
boolean isIncremental,
int nowInSec,
TopPartitionTracker.Collector topPartitionCollector) |
void |
CassandraTableRepairManager.incrementalSessionCompleted(TimeUUID sessionID) |
Future<java.util.List<java.lang.Void>> |
CassandraKeyspaceRepairManager.prepareIncrementalRepair(TimeUUID sessionID,
java.util.Collection<ColumnFamilyStore> tables,
RangesAtEndpoint tokenRanges,
java.util.concurrent.ExecutorService executor,
java.util.function.BooleanSupplier isCancelled) |
Constructor and Description |
---|
AcquisitionCallable(ColumnFamilyStore cfs,
java.util.Collection<Range<Token>> ranges,
TimeUUID sessionID,
int acquireRetrySeconds,
int acquireSleepMillis) |
CassandraValidationIterator(ColumnFamilyStore cfs,
java.util.Collection<Range<Token>> ranges,
TimeUUID parentId,
TimeUUID sessionID,
boolean isIncremental,
int nowInSec,
TopPartitionTracker.Collector topPartitionCollector) |
PendingAntiCompaction(TimeUUID prsId,
java.util.Collection<ColumnFamilyStore> tables,
RangesAtEndpoint tokenRanges,
java.util.concurrent.ExecutorService executor,
java.util.function.BooleanSupplier isCancelled) |
Modifier and Type | Field and Description |
---|---|
protected TimeUUID |
CassandraStreamReader.pendingRepair |
Modifier and Type | Method and Description |
---|---|
TimeUUID |
CassandraOutgoingFile.getPendingRepair() |
Modifier and Type | Method and Description |
---|---|
java.util.Collection<OutgoingStream> |
CassandraStreamManager.createOutgoingStreams(StreamSession session,
RangesAtEndpoint replicas,
TimeUUID pendingRepair,
PreviewKind previewKind) |
protected SSTableMultiWriter |
CassandraStreamReader.createWriter(ColumnFamilyStore cfs,
long totalSize,
long repairedAt,
TimeUUID pendingRepair,
SSTableFormat.Type format) |
Modifier and Type | Method and Description |
---|---|
static SSTableTxnWriter |
SSTableTxnWriter.create(ColumnFamilyStore cfs,
Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
int sstableLevel,
SerializationHeader header) |
static SSTableTxnWriter |
SSTableTxnWriter.create(ColumnFamilyStore cfs,
Descriptor desc,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
SerializationHeader header) |
static SSTableMultiWriter |
SimpleSSTableMultiWriter.create(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
TableMetadataRef metadata,
MetadataCollector metadataCollector,
SerializationHeader header,
java.util.Collection<Index> indexes,
LifecycleNewTracker lifecycleNewTracker) |
static SSTableTxnWriter |
SSTableTxnWriter.create(TableMetadataRef metadata,
Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
int sstableLevel,
SerializationHeader header,
java.util.Collection<Index> indexes) |
static SSTableTxnWriter |
SSTableTxnWriter.createRangeAware(TableMetadataRef metadata,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
SSTableFormat.Type type,
int sstableLevel,
SerializationHeader header) |
static void |
SSTable.validateRepairedMetadata(long repairedAt,
TimeUUID pendingRepair,
boolean isTransient) |
Constructor and Description |
---|
UUIDBasedSSTableId(TimeUUID uuid) |
Modifier and Type | Field and Description |
---|---|
protected TimeUUID |
SSTableWriter.pendingRepair |
Modifier and Type | Method and Description |
---|---|
TimeUUID |
SSTableReader.getPendingRepair() |
Modifier and Type | Method and Description |
---|---|
static SSTableWriter |
SSTableWriter.create(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
int sstableLevel,
SerializationHeader header,
java.util.Collection<Index> indexes,
LifecycleNewTracker lifecycleNewTracker) |
static SSTableWriter |
SSTableWriter.create(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
SerializationHeader header,
java.util.Collection<Index> indexes,
LifecycleNewTracker lifecycleNewTracker) |
static SSTableWriter |
SSTableWriter.create(Descriptor descriptor,
java.lang.Long keyCount,
java.lang.Long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
TableMetadataRef metadata,
MetadataCollector metadataCollector,
SerializationHeader header,
java.util.Collection<Index> indexes,
LifecycleNewTracker lifecycleNewTracker) |
static SSTableWriter |
SSTableWriter.create(TableMetadataRef metadata,
Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
int sstableLevel,
SerializationHeader header,
java.util.Collection<Index> indexes,
LifecycleNewTracker lifecycleNewTracker) |
void |
SSTableReader.mutateRepairedAndReload(long newRepairedAt,
TimeUUID newPendingRepair,
boolean isTransient)
Mutate sstable repair metadata with a lock to avoid racing with entire-sstable-streaming and then reload sstable metadata
|
abstract SSTableWriter |
SSTableWriter.Factory.open(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
TableMetadataRef metadata,
MetadataCollector metadataCollector,
SerializationHeader header,
java.util.Collection<SSTableFlushObserver> observers,
LifecycleNewTracker lifecycleNewTracker) |
Constructor and Description |
---|
RangeAwareSSTableWriter(ColumnFamilyStore cfs,
long estimatedKeys,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
SSTableFormat.Type format,
int sstableLevel,
long totalSize,
LifecycleNewTracker lifecycleNewTracker,
SerializationHeader header) |
SSTableWriter(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
TableMetadataRef metadata,
MetadataCollector metadataCollector,
SerializationHeader header,
java.util.Collection<SSTableFlushObserver> observers) |
Constructor and Description |
---|
BigTableWriter(Descriptor descriptor,
long keyCount,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
TableMetadataRef metadata,
MetadataCollector metadataCollector,
SerializationHeader header,
java.util.Collection<SSTableFlushObserver> observers,
LifecycleNewTracker lifecycleNewTracker) |
Modifier and Type | Field and Description |
---|---|
TimeUUID |
StatsMetadata.pendingRepair |
Modifier and Type | Method and Description |
---|---|
java.util.Map<MetadataType,MetadataComponent> |
MetadataCollector.finalizeMetadata(java.lang.String partitioner,
double bloomFilterFPChance,
long repairedAt,
TimeUUID pendingRepair,
boolean isTransient,
SerializationHeader header) |
StatsMetadata |
StatsMetadata.mutateRepairedMetadata(long newRepairedAt,
TimeUUID newPendingRepair,
boolean newIsTransient) |
void |
IMetadataSerializer.mutateRepairMetadata(Descriptor descriptor,
long newRepairedAt,
TimeUUID newPendingRepair,
boolean isTransient)
Mutate the repairedAt time, pendingRepair ID, and transient status.
|
void |
MetadataSerializer.mutateRepairMetadata(Descriptor descriptor,
long newRepairedAt,
TimeUUID newPendingRepair,
boolean isTransient) |
Constructor and Description |
---|
StatsMetadata(EstimatedHistogram estimatedPartitionSize,
EstimatedHistogram estimatedCellPerPartitionCount,
IntervalSet<CommitLogPosition> commitLogIntervals,
long minTimestamp,
long maxTimestamp,
int minLocalDeletionTime,
int maxLocalDeletionTime,
int minTTL,
int maxTTL,
double compressionRatio,
TombstoneHistogram estimatedTombstoneDropTime,
int sstableLevel,
java.util.List<java.nio.ByteBuffer> minClusteringValues,
java.util.List<java.nio.ByteBuffer> maxClusteringValues,
boolean hasLegacyCounterShards,
long repairedAt,
long totalColumnsSet,
long totalRows,
java.util.UUID originatingHostId,
TimeUUID pendingRepair,
boolean isTransient) |
Modifier and Type | Method and Description |
---|---|
TimeUUID |
Message.traceSession() |
TimeUUID |
Message.Header.traceSession() |
Modifier and Type | Field and Description |
---|---|
TimeUUID |
RepairJobDesc.parentSessionId |
TimeUUID |
RepairJobDesc.sessionId
RepairSession id
|
TimeUUID |
RepairSessionResult.sessionId |
Modifier and Type | Method and Description |
---|---|
TimeUUID |
RepairSession.getId() |
Modifier and Type | Method and Description |
---|---|
ValidationPartitionIterator |
TableRepairManager.getValidationIterator(java.util.Collection<Range<Token>> ranges,
TimeUUID parentId,
TimeUUID sessionID,
boolean isIncremental,
int nowInSec,
TopPartitionTracker.Collector topPartitionCollector)
Return a validation iterator for the given parameters.
|
void |
TableRepairManager.incrementalSessionCompleted(TimeUUID sessionID)
Called when the given incremental session has completed.
|
Future<java.util.List<java.lang.Void>> |
KeyspaceRepairManager.prepareIncrementalRepair(TimeUUID sessionID,
java.util.Collection<ColumnFamilyStore> tables,
RangesAtEndpoint tokenRanges,
java.util.concurrent.ExecutorService executor,
java.util.function.BooleanSupplier isCancelled)
Isolate the unrepaired ranges of the given tables, and make referenceable by session id.
|
protected Future<CoordinatedRepairResult> |
AbstractRepairTask.runRepair(TimeUUID parentSession,
boolean isIncremental,
ExecutorPlus executor,
java.util.List<CommonRange> commonRanges,
java.lang.String... cfnames) |
Constructor and Description |
---|
IncrementalRepairTask(RepairOption options,
java.lang.String keyspace,
RepairNotifier notifier,
TimeUUID parentSession,
RepairRunnable.NeighborsAndRanges neighborsAndRanges,
java.lang.String[] cfnames) |
LocalSyncTask(RepairJobDesc desc,
InetAddressAndPort local,
InetAddressAndPort remote,
java.util.List<Range<Token>> diff,
TimeUUID pendingRepair,
boolean requestRanges,
boolean transferRanges,
PreviewKind previewKind) |
NormalRepairTask(RepairOption options,
java.lang.String keyspace,
RepairNotifier notifier,
TimeUUID parentSession,
java.util.List<CommonRange> commonRanges,
java.lang.String[] cfnames) |
NoSuchRepairSessionException(TimeUUID parentSessionId) |
PreviewRepairTask(RepairOption options,
java.lang.String keyspace,
RepairNotifier notifier,
TimeUUID parentSession,
java.util.List<CommonRange> commonRanges,
java.lang.String[] cfnames) |
RepairJobDesc(TimeUUID parentSessionId,
TimeUUID sessionId,
java.lang.String keyspace,
java.lang.String columnFamily,
java.util.Collection<Range<Token>> ranges) |
RepairSession(TimeUUID parentRepairSession,
CommonRange commonRange,
java.lang.String keyspace,
RepairParallelism parallelismDegree,
boolean isIncremental,
boolean pullRepair,
PreviewKind previewKind,
boolean optimiseStreams,
boolean repairPaxos,
boolean paxosOnly,
java.lang.String... cfnames)
Create new repair session.
|
RepairSessionResult(TimeUUID 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,
TimeUUID pendingRepair,
PreviewKind previewKind,
boolean asymmetric) |
Modifier and Type | Field and Description |
---|---|
TimeUUID |
ConsistentSession.sessionID |
Modifier and Type | Method and Description |
---|---|
void |
LocalSessions.cancelSession(TimeUUID sessionID,
boolean force)
hook for operators to cancel sessions, cancelling from a non-coordinator is an error, unless
force is set to true.
|
void |
LocalSessions.deleteSession(TimeUUID sessionID) |
void |
LocalSessions.failSession(TimeUUID sessionID) |
void |
LocalSessions.failSession(TimeUUID sessionID,
boolean sendMessage) |
long |
LocalSessions.getFinalSessionRepairedAt(TimeUUID sessionID)
Returns the repairedAt time for a sessions which is unknown, failed, or finalized
calling this for a session which is in progress throws an exception
|
protected ActiveRepairService.ParentRepairSession |
LocalSessions.getParentRepairSession(TimeUUID sessionID) |
CoordinatorSession |
CoordinatorSessions.getSession(TimeUUID sessionId) |
LocalSession |
LocalSessions.getSession(TimeUUID sessionID) |
boolean |
LocalSessions.isSessionFinalized(TimeUUID sessionID)
determines if a local session exists, and if it's in the finalized state
|
boolean |
LocalSessions.isSessionInProgress(TimeUUID sessionID)
determines if a local session exists, and if it's not finalized or failed
|
void |
LocalSessions.maybeSetRepairing(TimeUUID sessionID) |
CoordinatorSession |
CoordinatorSessions.registerSession(TimeUUID sessionId,
java.util.Set<InetAddressAndPort> participants,
boolean isForced) |
boolean |
LocalSessions.sessionExists(TimeUUID sessionID)
determines if a local session exists
|
Modifier and Type | Field and Description |
---|---|
java.util.Set<TimeUUID> |
PendingStat.sessions |
java.util.Set<TimeUUID> |
PendingStat.Builder.sessions |
java.util.Set<TimeUUID> |
CleanupSummary.successful |
java.util.Set<TimeUUID> |
CleanupSummary.unsuccessful |
Constructor and Description |
---|
CleanupSummary(ColumnFamilyStore cfs,
java.util.Set<TimeUUID> successful,
java.util.Set<TimeUUID> unsuccessful) |
CleanupSummary(ColumnFamilyStore cfs,
java.util.Set<TimeUUID> successful,
java.util.Set<TimeUUID> unsuccessful) |
CleanupSummary(java.lang.String keyspace,
java.lang.String table,
java.util.Set<TimeUUID> successful,
java.util.Set<TimeUUID> unsuccessful) |
CleanupSummary(java.lang.String keyspace,
java.lang.String table,
java.util.Set<TimeUUID> successful,
java.util.Set<TimeUUID> unsuccessful) |
PendingStat(long dataSize,
int numSSTables,
java.util.Set<TimeUUID> sessions) |
Modifier and Type | Field and Description |
---|---|
TimeUUID |
CleanupMessage.parentRepairSession |
TimeUUID |
PrepareMessage.parentRepairSession |
TimeUUID |
PrepareConsistentRequest.parentSession |
TimeUUID |
PrepareConsistentResponse.parentSession |
TimeUUID |
FailSession.sessionID |
TimeUUID |
FinalizeCommit.sessionID |
TimeUUID |
FinalizePromise.sessionID |
TimeUUID |
FinalizePropose.sessionID |
TimeUUID |
StatusRequest.sessionID |
TimeUUID |
StatusResponse.sessionID |
Constructor and Description |
---|
CleanupMessage(TimeUUID parentRepairSession) |
FailSession(TimeUUID sessionID) |
FinalizeCommit(TimeUUID sessionID) |
FinalizePromise(TimeUUID sessionID,
InetAddressAndPort participant,
boolean promised) |
FinalizePropose(TimeUUID sessionID) |
PrepareConsistentRequest(TimeUUID parentSession,
InetAddressAndPort coordinator,
java.util.Set<InetAddressAndPort> participants) |
PrepareConsistentResponse(TimeUUID parentSession,
InetAddressAndPort participant,
boolean success) |
PrepareMessage(TimeUUID parentRepairSession,
java.util.List<TableId> tableIds,
java.util.Collection<Range<Token>> ranges,
boolean isIncremental,
long repairedAt,
boolean isGlobal,
PreviewKind previewKind) |
StatusRequest(TimeUUID sessionID) |
StatusResponse(TimeUUID sessionID,
ConsistentSession.State state) |
Modifier and Type | Field and Description |
---|---|
TimeUUID |
SessionState.parentRepairSession |
Modifier and Type | Method and Description |
---|---|
java.util.Set<TimeUUID> |
CoordinatorState.getSessionIds() |
Constructor and Description |
---|
SessionState(TimeUUID parentRepairSession,
java.lang.String keyspace,
java.lang.String[] cfnames,
CommonRange commonRange) |
Modifier and Type | Method and Description |
---|---|
static void |
SystemDistributedKeyspace.failedRepairJob(TimeUUID id,
java.lang.String keyspaceName,
java.lang.String cfname,
java.lang.Throwable t) |
static void |
SystemDistributedKeyspace.failParentRepair(TimeUUID parent_id,
java.lang.Throwable t) |
static void |
SystemDistributedKeyspace.failRepairs(TimeUUID id,
java.lang.String keyspaceName,
java.lang.String[] cfnames,
java.lang.Throwable t) |
static void |
SystemDistributedKeyspace.startParentRepair(TimeUUID parent_id,
java.lang.String keyspaceName,
java.lang.String[] cfnames,
RepairOption options) |
static void |
SystemDistributedKeyspace.startRepairs(TimeUUID id,
TimeUUID parent_id,
java.lang.String keyspaceName,
java.lang.String[] cfnames,
CommonRange commonRange) |
static void |
SystemDistributedKeyspace.successfulParentRepair(TimeUUID parent_id,
java.util.Collection<Range<Token>> successfulRanges) |
static void |
SystemDistributedKeyspace.successfulRepairJob(TimeUUID id,
java.lang.String keyspaceName,
java.lang.String cfname) |
Modifier and Type | Field and Description |
---|---|
static TimeUUID |
ActiveRepairService.NO_PENDING_REPAIR |
Modifier and Type | Method and Description |
---|---|
TimeUUID |
ActiveRepairService.prepareForRepair(TimeUUID parentRepairSession,
InetAddressAndPort coordinator,
java.util.Set<InetAddressAndPort> endpoints,
RepairOption options,
boolean isForcedRepair,
java.util.List<ColumnFamilyStore> columnFamilyStores) |
Modifier and Type | Method and Description |
---|---|
void |
ActiveRepairService.cleanUp(TimeUUID parentRepairSession,
java.util.Set<InetAddressAndPort> endpoints)
Send Verb.CLEANUP_MSG to the given endpoints.
|
CoordinatorState |
ActiveRepairService.coordinator(TimeUUID id) |
ActiveRepairService.ParentRepairSession |
ActiveRepairService.getParentRepairSession(TimeUUID parentSessionId)
We assume when calling this method that a parent session for the provided identifier
exists, and that session is still in progress.
|
ParticipateState |
ActiveRepairService.participate(TimeUUID id) |
TimeUUID |
ActiveRepairService.prepareForRepair(TimeUUID parentRepairSession,
InetAddressAndPort coordinator,
java.util.Set<InetAddressAndPort> endpoints,
RepairOption options,
boolean isForcedRepair,
java.util.List<ColumnFamilyStore> columnFamilyStores) |
void |
ActiveRepairService.registerParentRepairSession(TimeUUID parentRepairSession,
InetAddressAndPort coordinator,
java.util.List<ColumnFamilyStore> columnFamilyStores,
java.util.Collection<Range<Token>> ranges,
boolean isIncremental,
long repairedAt,
boolean isGlobal,
PreviewKind previewKind) |
ActiveRepairService.ParentRepairSession |
ActiveRepairService.removeParentRepairSession(TimeUUID parentSessionId)
called when the repair session is done - either failed or anticompaction has completed
|
RepairSession |
ActiveRepairService.submitRepairSession(TimeUUID parentRepairSession,
CommonRange range,
java.lang.String keyspace,
RepairParallelism parallelismDegree,
boolean isIncremental,
boolean pullRepair,
PreviewKind previewKind,
boolean optimiseStreams,
boolean repairPaxos,
boolean paxosOnly,
ExecutorPlus executor,
java.lang.String... cfnames)
Requests repairs for the given keyspace and column families.
|
static boolean |
ActiveRepairService.verifyCompactionsPendingThreshold(TimeUUID parentRepairSession,
PreviewKind previewKind) |
Modifier and Type | Class and Description |
---|---|
class |
Ballot |
Modifier and Type | Field and Description |
---|---|
TimeUUID |
StreamEvent.planId |
TimeUUID |
StreamResultFuture.planId |
TimeUUID |
StreamState.planId |
Modifier and Type | Method and Description |
---|---|
TimeUUID |
OutgoingStream.getPendingRepair() |
TimeUUID |
StreamCoordinator.getPendingRepair() |
TimeUUID |
StreamPlan.getPendingRepair() |
TimeUUID |
StreamSession.getPendingRepair() |
TimeUUID |
StreamingState.id() |
TimeUUID |
StreamSession.planId() |
Modifier and Type | Method and Description |
---|---|
static StreamResultFuture |
StreamResultFuture.createFollower(int sessionIndex,
TimeUUID planId,
StreamOperation streamOperation,
InetAddressAndPort from,
StreamingChannel channel,
int messagingVersion,
TimeUUID pendingRepair,
PreviewKind previewKind) |
static StreamResultFuture |
StreamResultFuture.createInitiator(TimeUUID planId,
StreamOperation streamOperation,
java.util.Collection<StreamEventHandler> listeners,
StreamCoordinator coordinator) |
java.util.Collection<OutgoingStream> |
TableStreamManager.createOutgoingStreams(StreamSession session,
RangesAtEndpoint replicas,
TimeUUID pendingRepair,
PreviewKind previewKind)
Returns a collection of
OutgoingStream s that contains the data selected by the
given replicas, pendingRepair, and preview. |
StreamSession |
StreamManager.findSession(InetAddressAndPort peer,
TimeUUID planId,
int sessionIndex,
boolean searchInitiatorSessions) |
StreamResultFuture |
StreamManager.getInitiatorStream(TimeUUID planId) |
java.util.List<OutgoingStream> |
StreamSession.getOutgoingStreamsForRanges(RangesAtEndpoint replicas,
java.util.Collection<ColumnFamilyStore> stores,
TimeUUID pendingRepair,
PreviewKind previewKind) |
StreamResultFuture |
StreamManager.getReceivingStream(TimeUUID planId) |
StreamingState |
StreamManager.getStreamingState(TimeUUID id) |
java.lang.String |
PreviewKind.logPrefix(TimeUUID sessionId) |
Constructor and Description |
---|
ProgressEvent(TimeUUID planId,
ProgressInfo progress) |
SessionPreparedEvent(TimeUUID planId,
SessionInfo session,
StreamSession.PrepareDirection prepareDirection) |
StreamCoordinator(StreamOperation streamOperation,
int connectionsPerHost,
StreamingChannel.Factory factory,
boolean follower,
boolean connectSequentially,
TimeUUID pendingRepair,
PreviewKind previewKind) |
StreamEvent(StreamEvent.Type eventType,
TimeUUID planId) |
StreamPlan(StreamOperation streamOperation,
int connectionsPerHost,
boolean connectSequentially,
TimeUUID pendingRepair,
PreviewKind previewKind) |
StreamResultFuture(TimeUUID planId,
StreamOperation streamOperation,
StreamCoordinator coordinator)
Create new StreamResult of given
planId and streamOperation. |
StreamResultFuture(TimeUUID planId,
StreamOperation streamOperation,
TimeUUID pendingRepair,
PreviewKind previewKind) |
StreamSession(StreamOperation streamOperation,
InetAddressAndPort peer,
StreamingChannel.Factory factory,
StreamingChannel controlChannel,
int messagingVersion,
boolean isFollower,
int index,
TimeUUID pendingRepair,
PreviewKind previewKind)
Create new streaming session with the peer.
|
StreamState(TimeUUID planId,
StreamOperation streamOperation,
java.util.Set<SessionInfo> sessions) |
Modifier and Type | Method and Description |
---|---|
static javax.management.openmbean.CompositeData |
ProgressInfoCompositeData.toCompositeData(TimeUUID planId,
ProgressInfo progressInfo) |
static javax.management.openmbean.CompositeData |
SessionInfoCompositeData.toCompositeData(TimeUUID planId,
SessionInfo sessionInfo) |
Modifier and Type | Field and Description |
---|---|
TimeUUID |
StreamInitMessage.pendingRepair |
TimeUUID |
StreamMessageHeader.pendingRepair |
TimeUUID |
StreamInitMessage.planId |
TimeUUID |
StreamMessageHeader.planId |
Constructor and Description |
---|
StreamInitMessage(InetAddressAndPort from,
int sessionIndex,
TimeUUID planId,
StreamOperation streamOperation,
TimeUUID pendingRepair,
PreviewKind previewKind) |
StreamMessageHeader(TableId tableId,
InetAddressAndPort sender,
TimeUUID planId,
boolean sendByFollower,
int sessionIndex,
int sequenceNumber,
long repairedAt,
TimeUUID pendingRepair) |
Modifier and Type | Field and Description |
---|---|
TimeUUID |
TraceState.sessionId |
Modifier and Type | Field and Description |
---|---|
protected java.util.concurrent.ConcurrentMap<TimeUUID,TraceState> |
Tracing.sessions |
Modifier and Type | Method and Description |
---|---|
TimeUUID |
Tracing.getSessionId() |
TimeUUID |
Tracing.newSession(java.util.Map<java.lang.String,java.nio.ByteBuffer> customPayload) |
TimeUUID |
Tracing.newSession(TimeUUID sessionId,
java.util.Map<java.lang.String,java.nio.ByteBuffer> customPayload) |
protected TimeUUID |
Tracing.newSession(TimeUUID sessionId,
Tracing.TraceType traceType,
java.util.Map<java.lang.String,java.nio.ByteBuffer> customPayload)
This method is intended to be overridden in tracing implementations that need access to the customPayload
|
TimeUUID |
Tracing.newSession(Tracing.TraceType traceType) |
Modifier and Type | Method and Description |
---|---|
TraceState |
Tracing.get(TimeUUID sessionId) |
TimeUUID |
Tracing.newSession(TimeUUID sessionId,
java.util.Map<java.lang.String,java.nio.ByteBuffer> customPayload) |
protected TimeUUID |
Tracing.newSession(TimeUUID sessionId,
Tracing.TraceType traceType,
java.util.Map<java.lang.String,java.nio.ByteBuffer> customPayload)
This method is intended to be overridden in tracing implementations that need access to the customPayload
|
protected abstract TraceState |
Tracing.newTraceState(InetAddressAndPort coordinator,
TimeUUID sessionId,
Tracing.TraceType traceType) |
Constructor and Description |
---|
TraceState(InetAddressAndPort coordinator,
TimeUUID sessionId,
Tracing.TraceType traceType) |
TraceStateImpl(InetAddressAndPort coordinator,
TimeUUID sessionId,
Tracing.TraceType traceType) |
Modifier and Type | Field and Description |
---|---|
protected TimeUUID |
Message.Response.tracingId |
Modifier and Type | Method and Description |
---|---|
static TimeUUID |
CBUtil.readTimeUUID(io.netty.buffer.ByteBuf cb) |
Modifier and Type | Method and Description |
---|---|
static void |
CBUtil.writeUUID(TimeUUID uuid,
io.netty.buffer.ByteBuf cb) |
Modifier and Type | Class and Description |
---|---|
protected static class |
TimeUUID.AbstractSerializer<T extends TimeUUID> |
Modifier and Type | Method and Description |
---|---|
static TimeUUID |
TimeUUID.atUnixMicrosWithLsb(long unixMicros,
long uniqueLsb) |
static TimeUUID |
TimeUUID.Generator.atUnixMillis(long unixMillis) |
static TimeUUID |
TimeUUID.Generator.atUnixMillis(long unixMillis,
long tenthsOfAMicro) |
static TimeUUID |
TimeUUID.deserialize(java.nio.ByteBuffer buffer) |
static TimeUUID |
TimeUUID.deserialize(java.io.DataInput in) |
TimeUUID |
TimeUUID.Serializer.deserialize(DataInputPlus in,
int version) |
<V> TimeUUID |
TimeUUID.Serializer.deserialize(V value,
ValueAccessor<V> accessor) |
static TimeUUID |
TimeUUID.fromBytes(long msb,
long lsb) |
static TimeUUID |
TimeUUID.fromString(java.lang.String uuidString) |
static TimeUUID |
TimeUUID.fromUuid(java.util.UUID uuid) |
static TimeUUID |
TimeUUID.maxAtUnixMillis(long unixMillis)
Returns the biggest possible type 1 UUID having the provided timestamp.
|
static TimeUUID |
TimeUUID.minAtUnixMillis(long unixMillis)
Returns the smaller possible type 1 UUID having the provided timestamp.
|
static TimeUUID |
TimeUUID.Generator.nextTimeUUID() |
Modifier and Type | Method and Description |
---|---|
java.lang.Class<TimeUUID> |
TimeUUID.Serializer.getType() |
Modifier and Type | Method and Description |
---|---|
static java.nio.ByteBuffer |
ByteBufferUtil.bytes(TimeUUID uuid) |
int |
TimeUUID.compareTo(TimeUUID that) |
boolean |
TimeUUID.equals(TimeUUID that) |
void |
TimeUUID.Serializer.serialize(TimeUUID t,
DataOutputPlus out,
int version) |
long |
TimeUUID.Serializer.serializedSize(TimeUUID t,
int version) |
static java.lang.String |
TimeUUID.toString(TimeUUID ballot) |
static java.lang.String |
TimeUUID.toString(TimeUUID ballot,
java.lang.String kind) |
Copyright © 2009- The Apache Software Foundation