StorageProxy (apache-cassandra API)

java.lang.Object
- org.apache.cassandra.service.StorageProxy

All Implemented Interfaces:: StorageProxyMBean

public class StorageProxy
extends java.lang.Object
implements StorageProxyMBean

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface StorageProxy.WritePerformer

Nested Classes
Modifier and Type	Class and Description
`static interface`	`StorageProxy.WritePerformer`

Field Summary

Fields
Modifier and Type Field and Description

static StorageProxy instance

static java.lang.String MBEAN_NAME

static java.lang.String UNREACHABLE

Fields
Modifier and Type	Field and Description
`static StorageProxy`	`instance`
`static java.lang.String`	`MBEAN_NAME`
`static java.lang.String`	`UNREACHABLE`

Method Summary

Methods
Modifier and Type	Method and Description
`static AbstractWriteResponseHandler`	`applyCounterMutationOnCoordinator(CounterMutation cm, java.lang.String localDataCenter)`
`static AbstractWriteResponseHandler`	`applyCounterMutationOnLeader(CounterMutation cm, java.lang.String localDataCenter, java.lang.Runnable callback)`
`static ColumnFamily`	`cas(java.lang.String keyspaceName, java.lang.String cfName, java.nio.ByteBuffer key, ColumnNameBuilder prefix, ColumnFamily expected, ColumnFamily updates, ConsistencyLevel consistencyForPaxos, ConsistencyLevel consistencyForCommit)` Apply @param updates if and only if the current values in the row for @param key match the ones given by @param expected.
`static java.util.Map<java.lang.String,java.util.List<java.lang.String>>`	`describeSchemaVersions()` initiate a request/response session with each live node to check whether or not everybody is using the same migration id.
`java.lang.Long`	`getCasContentionTimeout()`
`boolean`	`getHintedHandoffEnabled()`
`int`	`getHintsInProgress()`
`static java.util.List<java.net.InetAddress>`	`getLiveSortedEndpoints(Keyspace keyspace, java.nio.ByteBuffer key)`
`int`	`getMaxHintsInProgress()`
`int`	`getMaxHintWindow()`
`long`	`getRangeOperations()`
`java.lang.Long`	`getRangeRpcTimeout()`
`static java.util.List<Row>`	`getRangeSlice(AbstractRangeCommand command, ConsistencyLevel consistency_level)`
`long`	`getReadOperations()`
`long`	`getReadRepairAttempted()`
`long`	`getReadRepairRepairedBackground()`
`long`	`getReadRepairRepairedBlocking()`
`java.lang.Long`	`getReadRpcTimeout()`
`long[]`	`getRecentRangeLatencyHistogramMicros()`
`double`	`getRecentRangeLatencyMicros()`
`long[]`	`getRecentReadLatencyHistogramMicros()`
`double`	`getRecentReadLatencyMicros()`
`long[]`	`getRecentWriteLatencyHistogramMicros()`
`double`	`getRecentWriteLatencyMicros()`
`java.lang.Long`	`getRpcTimeout()`
`long`	`getTotalHints()`
`long[]`	`getTotalRangeLatencyHistogramMicros()`
`long`	`getTotalRangeLatencyMicros()`
`long[]`	`getTotalReadLatencyHistogramMicros()`
`long`	`getTotalReadLatencyMicros()`
`long[]`	`getTotalWriteLatencyHistogramMicros()`
`long`	`getTotalWriteLatencyMicros()`
`java.lang.Long`	`getTruncateRpcTimeout()`
`long`	`getWriteOperations()`
`java.lang.Long`	`getWriteRpcTimeout()`
`static void`	`mutate(java.util.Collection<? extends IMutation> mutations, ConsistencyLevel consistency_level)` Use this method to have these Mutations applied across all replicas.
`static void`	`mutateAtomically(java.util.Collection<RowMutation> mutations, ConsistencyLevel consistency_level)` See mutate.
`static AbstractWriteResponseHandler`	`mutateCounter(CounterMutation cm, java.lang.String localDataCenter)` Handle counter mutation on the coordinator host.
`static void`	`mutateWithTriggers(java.util.Collection<? extends IMutation> mutations, ConsistencyLevel consistencyLevel, boolean mutateAtomically)`
`static AbstractWriteResponseHandler`	`performWrite(IMutation mutation, ConsistencyLevel consistency_level, java.lang.String localDataCenter, StorageProxy.WritePerformer performer, java.lang.Runnable callback, WriteType writeType)` Perform the write of a mutation given a WritePerformer.
`static java.util.List<Row>`	`read(java.util.List<ReadCommand> commands, ConsistencyLevel consistency_level)` Performs the actual reading of a row out of the StorageService, fetching a specific set of column names from a given column family.
`void`	`reloadTriggerClass()`
`static void`	`sendToHintedEndpoints(RowMutation rm, java.lang.Iterable<java.net.InetAddress> targets, AbstractWriteResponseHandler responseHandler, java.lang.String localDataCenter, ConsistencyLevel consistency_level)` Send the mutations to the right targets, write it locally if it corresponds or writes a hint when the node is not available.
`void`	`setCasContentionTimeout(java.lang.Long timeoutInMillis)`
`void`	`setHintedHandoffEnabled(boolean b)`
`void`	`setMaxHintsInProgress(int qs)`
`void`	`setMaxHintWindow(int ms)`
`void`	`setRangeRpcTimeout(java.lang.Long timeoutInMillis)`
`void`	`setReadRpcTimeout(java.lang.Long timeoutInMillis)`
`void`	`setRpcTimeout(java.lang.Long timeoutInMillis)`
`void`	`setTruncateRpcTimeout(java.lang.Long timeoutInMillis)`
`void`	`setWriteRpcTimeout(java.lang.Long timeoutInMillis)`
`static boolean`	`shouldHint(java.net.InetAddress ep)`
`static java.util.concurrent.Future<java.lang.Void>`	`submitHint(RowMutation mutation, java.net.InetAddress target, AbstractWriteResponseHandler responseHandler, ConsistencyLevel consistencyLevel)`
`static void`	`truncateBlocking(java.lang.String keyspace, java.lang.String cfname)` Performs the truncate operatoin, which effectively deletes all data from the column family cfname
`void`	`verifyNoHintsInProgress()`
`static void`	`writeHintForMutation(RowMutation mutation, int ttl, java.net.InetAddress target)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - MBEAN_NAME
```
public static final java.lang.String MBEAN_NAME
```
    See Also:
    Constant Field Values
  - UNREACHABLE
```
public static final java.lang.String UNREACHABLE
```
    See Also:
    Constant Field Values
  - instance
```
public static final StorageProxy instance
```
- Method Detail
  - cas
```
public static ColumnFamily cas(java.lang.String keyspaceName,
               java.lang.String cfName,
               java.nio.ByteBuffer key,
               ColumnNameBuilder prefix,
               ColumnFamily expected,
               ColumnFamily updates,
               ConsistencyLevel consistencyForPaxos,
               ConsistencyLevel consistencyForCommit)
                        throws UnavailableException,
                               IsBootstrappingException,
                               ReadTimeoutException,
                               WriteTimeoutException,
                               InvalidRequestException
```
    Apply @param updates if and only if the current values in the row for @param key match the ones given by @param expected. The algorithm is "raw" Paxos: that is, Paxos minus leader election -- any node in the cluster may propose changes for any row, which (that is, the row) is the unit of values being proposed, not single columns. The Paxos cohort is only the replicas for the given key, not the entire cluster. So we expect performance to be reasonable, but CAS is still intended to be used "when you really need it," not for all your updates. There are three phases to Paxos: 1. Prepare: the coordinator generates a ballot (timeUUID in our case) and asks replicas to (a) promise not to accept updates from older ballots and (b) tell us about the most recent update it has already accepted. 2. Accept: if a majority of replicas reply, the coordinator asks replicas to accept the value of the highest proposal ballot it heard about, or a new value if no in-progress proposals were reported. 3. Commit (Learn): if a majority of replicas acknowledge the accept request, we can commit the new value. Commit procedure is not covered in "Paxos Made Simple," and only briefly mentioned in "Paxos Made Live," so here is our approach: 3a. The coordinator sends a commit message to all replicas with the ballot and value. 3b. Because of 1-2, this will be the highest-seen commit ballot. The replicas will note that, and send it with subsequent promise replies. This allows us to discard acceptance records for successfully committed replicas, without allowing incomplete proposals to commit erroneously later on. Note that since we are performing a CAS rather than a simple update, we perform a read (of committed values) between the prepare and accept phases. This gives us a slightly longer window for another coordinator to come along and trump our own promise with a newer one but is otherwise safe.
    
    Parameters:
    keyspaceName - the keyspace for the CAS
    cfName - the column family for the CAS
    key - the row key for the row to CAS
    prefix - a column name prefix that selects the CQL3 row to check if expected is null. If expected is not null, this is ignored. If expected is null and this is null, the full row existing is checked (by querying the first live column of the row).
    expected - the expected column values. This can be null to check for existence (see prefix).
    updates - the value to insert if expected matches the current values.
    consistencyForPaxos - the consistency for the paxos prepare and propose round. This can only be either SERIAL or LOCAL_SERIAL.
    consistencyForCommit - the consistency for write done during the commit phase. This can be anything, except SERIAL or LOCAL_SERIAL.
    
    Returns:
    null if the operation succeeds in updating the row, or the current values for the columns contained in expected (since, if the CAS doesn't succeed, it means the current value do not match the one in expected). If expected == null and the CAS is unsuccessfull, the first live column of the CF is returned.
    
    Throws:
    
    UnavailableException
    
    IsBootstrappingException
    
    ReadTimeoutException
    
    WriteTimeoutException
    
    InvalidRequestException
  - mutate
```
public static void mutate(java.util.Collection<? extends IMutation> mutations,
          ConsistencyLevel consistency_level)
                   throws UnavailableException,
                          OverloadedException,
                          WriteTimeoutException
```
    Use this method to have these Mutations applied across all replicas. This method will take care of the possibility of a replica being down and hint the data across to some other replica.
    
    Parameters:
    mutations - the mutations to be applied across the replicas
    consistency_level - the consistency level for the operation
    
    Throws:
    
    UnavailableException
    
    OverloadedException
    
    WriteTimeoutException
  - mutateWithTriggers
```
public static void mutateWithTriggers(java.util.Collection<? extends IMutation> mutations,
                      ConsistencyLevel consistencyLevel,
                      boolean mutateAtomically)
                               throws WriteTimeoutException,
                                      UnavailableException,
                                      OverloadedException,
                                      InvalidRequestException
```
    Throws:
    
    WriteTimeoutException
    
    UnavailableException
    
    OverloadedException
    
    InvalidRequestException
  - mutateAtomically
```
public static void mutateAtomically(java.util.Collection<RowMutation> mutations,
                    ConsistencyLevel consistency_level)
                             throws UnavailableException,
                                    OverloadedException,
                                    WriteTimeoutException
```
    See mutate. Adds additional steps before and after writing a batch. Before writing the batch (but after doing availability check against the FD for the row replicas): write the entire batch to a batchlog elsewhere in the cluster. After: remove the batchlog entry (after writing hints for the batch rows, if necessary).
    
    Parameters:
    mutations - the RowMutations to be applied across the replicas
    consistency_level - the consistency level for the operation
    
    Throws:
    
    UnavailableException
    
    OverloadedException
    
    WriteTimeoutException
  - performWrite
```
public static AbstractWriteResponseHandler performWrite(IMutation mutation,
                                        ConsistencyLevel consistency_level,
                                        java.lang.String localDataCenter,
                                        StorageProxy.WritePerformer performer,
                                        java.lang.Runnable callback,
                                        WriteType writeType)
                                                 throws UnavailableException,
                                                        OverloadedException
```
    Perform the write of a mutation given a WritePerformer. Gather the list of write endpoints, apply locally and/or forward the mutation to said write endpoint (deletaged to the actual WritePerformer) and wait for the responses based on consistency level.
    
    Parameters:
    mutation - the mutation to be applied
    consistency_level - the consistency level for the write operation
    performer - the WritePerformer in charge of appliying the mutation given the list of write endpoints (either standardWritePerformer for standard writes or counterWritePerformer for counter writes).
    callback - an optional callback to be run if and when the write is successful.
    
    Throws:
    
    UnavailableException
    
    OverloadedException
  - sendToHintedEndpoints
```
public static void sendToHintedEndpoints(RowMutation rm,
                         java.lang.Iterable<java.net.InetAddress> targets,
                         AbstractWriteResponseHandler responseHandler,
                         java.lang.String localDataCenter,
                         ConsistencyLevel consistency_level)
                                  throws OverloadedException
```
    Send the mutations to the right targets, write it locally if it corresponds or writes a hint when the node is not available. Note about hints: | Hinted Handoff | Consist. Level | | on | >=1 | --> wait for hints. We DO NOT notify the handler with handler.response() for hints; | on | ANY | --> wait for hints. Responses count towards consistency. | off | >=1 | --> DO NOT fire hints. And DO NOT wait for them to complete. | off | ANY | --> DO NOT fire hints. And DO NOT wait for them to complete.
    
    Throws:
    
    java.util.concurrent.TimeoutException - if the hints cannot be written/enqueued
    
    OverloadedException
  - submitHint
```
public static java.util.concurrent.Future<java.lang.Void> submitHint(RowMutation mutation,
                                                     java.net.InetAddress target,
                                                     AbstractWriteResponseHandler responseHandler,
                                                     ConsistencyLevel consistencyLevel)
```
  - writeHintForMutation
```
public static void writeHintForMutation(RowMutation mutation,
                        int ttl,
                        java.net.InetAddress target)
```
  - mutateCounter
```
public static AbstractWriteResponseHandler mutateCounter(CounterMutation cm,
                                         java.lang.String localDataCenter)
                                                  throws UnavailableException,
                                                         OverloadedException
```
    Handle counter mutation on the coordinator host. A counter mutation needs to first be applied to a replica (that we'll call the leader for the mutation) before being replicated to the other endpoint. To achieve so, there is two case: 1) the coordinator host is a replica: we proceed to applying the update locally and replicate throug applyCounterMutationOnCoordinator 2) the coordinator is not a replica: we forward the (counter)mutation to a chosen replica (that will proceed through applyCounterMutationOnLeader upon receive) and wait for its acknowledgment. Implementation note: We check if we can fulfill the CL on the coordinator host even if he is not a replica to allow quicker response and because the WriteResponseHandlers don't make it easy to send back an error. We also always gather the write latencies at the coordinator node to make gathering point similar to the case of standard writes.
    
    Throws:
    
    UnavailableException
    
    OverloadedException
  - applyCounterMutationOnLeader
```
public static AbstractWriteResponseHandler applyCounterMutationOnLeader(CounterMutation cm,
                                                        java.lang.String localDataCenter,
                                                        java.lang.Runnable callback)
                                                                 throws UnavailableException,
                                                                        OverloadedException
```
    Throws:
    
    UnavailableException
    
    OverloadedException
  - applyCounterMutationOnCoordinator
```
public static AbstractWriteResponseHandler applyCounterMutationOnCoordinator(CounterMutation cm,
                                                             java.lang.String localDataCenter)
                                                                      throws UnavailableException,
                                                                             OverloadedException
```
    Throws:
    
    UnavailableException
    
    OverloadedException
  - read
```
public static java.util.List<Row> read(java.util.List<ReadCommand> commands,
                       ConsistencyLevel consistency_level)
                                throws UnavailableException,
                                       IsBootstrappingException,
                                       ReadTimeoutException,
                                       InvalidRequestException
```
    Performs the actual reading of a row out of the StorageService, fetching a specific set of column names from a given column family.
    
    Throws:
    
    UnavailableException
    
    IsBootstrappingException
    
    ReadTimeoutException
    
    InvalidRequestException
  - getLiveSortedEndpoints
```
public static java.util.List<java.net.InetAddress> getLiveSortedEndpoints(Keyspace keyspace,
                                                          java.nio.ByteBuffer key)
```
  - getRangeSlice
```
public static java.util.List<Row> getRangeSlice(AbstractRangeCommand command,
                                ConsistencyLevel consistency_level)
                                         throws UnavailableException,
                                                ReadTimeoutException
```
    Throws:
    
    UnavailableException
    
    ReadTimeoutException
  - describeSchemaVersions
```
public static java.util.Map<java.lang.String,java.util.List<java.lang.String>> describeSchemaVersions()
```
    initiate a request/response session with each live node to check whether or not everybody is using the same migration id. This is useful for determining if a schema change has propagated through the cluster. Disagreement is assumed if any node fails to respond.
  - getReadOperations
```
public long getReadOperations()
```
    Specified by:
    
    getReadOperations in interface StorageProxyMBean
    
    See Also:
    LatencyMetrics.lastOpCount
  - getTotalReadLatencyMicros
```
public long getTotalReadLatencyMicros()
```
    Specified by:
    
    getTotalReadLatencyMicros in interface StorageProxyMBean
    
    See Also:
    LatencyMetrics.totalLatencyHistogram
  - getRecentReadLatencyMicros
```
public double getRecentReadLatencyMicros()
```
    Specified by:
    
    getRecentReadLatencyMicros in interface StorageProxyMBean
    
    See Also:
    LatencyMetrics.recentLatencyHistogram
  - getTotalReadLatencyHistogramMicros
```
public long[] getTotalReadLatencyHistogramMicros()
```
    Specified by:
    
    getTotalReadLatencyHistogramMicros in interface StorageProxyMBean
    
    See Also:
    LatencyMetrics.totalLatencyHistogram
  - getRecentReadLatencyHistogramMicros
```
public long[] getRecentReadLatencyHistogramMicros()
```
    Specified by:
    
    getRecentReadLatencyHistogramMicros in interface StorageProxyMBean
    
    See Also:
    LatencyMetrics.recentLatencyHistogram
  - getRangeOperations
```
public long getRangeOperations()
```
    Specified by:
    
    getRangeOperations in interface StorageProxyMBean
  - getTotalRangeLatencyMicros
```
public long getTotalRangeLatencyMicros()
```
    Specified by:
    
    getTotalRangeLatencyMicros in interface StorageProxyMBean
  - getRecentRangeLatencyMicros
```
public double getRecentRangeLatencyMicros()
```
    Specified by:
    
    getRecentRangeLatencyMicros in interface StorageProxyMBean
  - getTotalRangeLatencyHistogramMicros
```
public long[] getTotalRangeLatencyHistogramMicros()
```
    Specified by:
    
    getTotalRangeLatencyHistogramMicros in interface StorageProxyMBean
  - getRecentRangeLatencyHistogramMicros
```
public long[] getRecentRangeLatencyHistogramMicros()
```
    Specified by:
    
    getRecentRangeLatencyHistogramMicros in interface StorageProxyMBean
  - getWriteOperations
```
public long getWriteOperations()
```
    Specified by:
    
    getWriteOperations in interface StorageProxyMBean
  - getTotalWriteLatencyMicros
```
public long getTotalWriteLatencyMicros()
```
    Specified by:
    
    getTotalWriteLatencyMicros in interface StorageProxyMBean
  - getRecentWriteLatencyMicros
```
public double getRecentWriteLatencyMicros()
```
    Specified by:
    
    getRecentWriteLatencyMicros in interface StorageProxyMBean
  - getTotalWriteLatencyHistogramMicros
```
public long[] getTotalWriteLatencyHistogramMicros()
```
    Specified by:
    
    getTotalWriteLatencyHistogramMicros in interface StorageProxyMBean
  - getRecentWriteLatencyHistogramMicros
```
public long[] getRecentWriteLatencyHistogramMicros()
```
    Specified by:
    
    getRecentWriteLatencyHistogramMicros in interface StorageProxyMBean
  - getHintedHandoffEnabled
```
public boolean getHintedHandoffEnabled()
```
    Specified by:
    
    getHintedHandoffEnabled in interface StorageProxyMBean
  - setHintedHandoffEnabled
```
public void setHintedHandoffEnabled(boolean b)
```
    Specified by:
    
    setHintedHandoffEnabled in interface StorageProxyMBean
  - getMaxHintWindow
```
public int getMaxHintWindow()
```
    Specified by:
    
    getMaxHintWindow in interface StorageProxyMBean
  - setMaxHintWindow
```
public void setMaxHintWindow(int ms)
```
    Specified by:
    
    setMaxHintWindow in interface StorageProxyMBean
  - shouldHint
```
public static boolean shouldHint(java.net.InetAddress ep)
```
  - truncateBlocking
```
public static void truncateBlocking(java.lang.String keyspace,
                    java.lang.String cfname)
                             throws UnavailableException,
                                    java.util.concurrent.TimeoutException,
                                    java.io.IOException
```
    Performs the truncate operatoin, which effectively deletes all data from the column family cfname
    
    Parameters:
    keyspace -
    cfname -
    
    Throws:
    
    UnavailableException - If some of the hosts in the ring are down.
    
    java.util.concurrent.TimeoutException
    
    java.io.IOException
  - getTotalHints
```
public long getTotalHints()
```
    Specified by:
    
    getTotalHints in interface StorageProxyMBean
  - getMaxHintsInProgress
```
public int getMaxHintsInProgress()
```
    Specified by:
    
    getMaxHintsInProgress in interface StorageProxyMBean
  - setMaxHintsInProgress
```
public void setMaxHintsInProgress(int qs)
```
    Specified by:
    
    setMaxHintsInProgress in interface StorageProxyMBean
  - getHintsInProgress
```
public int getHintsInProgress()
```
    Specified by:
    
    getHintsInProgress in interface StorageProxyMBean
  - verifyNoHintsInProgress
```
public void verifyNoHintsInProgress()
```
  - getRpcTimeout
```
public java.lang.Long getRpcTimeout()
```
    Specified by:
    
    getRpcTimeout in interface StorageProxyMBean
  - setRpcTimeout
```
public void setRpcTimeout(java.lang.Long timeoutInMillis)
```
    Specified by:
    
    setRpcTimeout in interface StorageProxyMBean
  - getReadRpcTimeout
```
public java.lang.Long getReadRpcTimeout()
```
    Specified by:
    
    getReadRpcTimeout in interface StorageProxyMBean
  - setReadRpcTimeout
```
public void setReadRpcTimeout(java.lang.Long timeoutInMillis)
```
    Specified by:
    
    setReadRpcTimeout in interface StorageProxyMBean
  - getWriteRpcTimeout
```
public java.lang.Long getWriteRpcTimeout()
```
    Specified by:
    
    getWriteRpcTimeout in interface StorageProxyMBean
  - setWriteRpcTimeout
```
public void setWriteRpcTimeout(java.lang.Long timeoutInMillis)
```
    Specified by:
    
    setWriteRpcTimeout in interface StorageProxyMBean
  - getCasContentionTimeout
```
public java.lang.Long getCasContentionTimeout()
```
    Specified by:
    
    getCasContentionTimeout in interface StorageProxyMBean
  - setCasContentionTimeout
```
public void setCasContentionTimeout(java.lang.Long timeoutInMillis)
```
    Specified by:
    
    setCasContentionTimeout in interface StorageProxyMBean
  - getRangeRpcTimeout
```
public java.lang.Long getRangeRpcTimeout()
```
    Specified by:
    
    getRangeRpcTimeout in interface StorageProxyMBean
  - setRangeRpcTimeout
```
public void setRangeRpcTimeout(java.lang.Long timeoutInMillis)
```
    Specified by:
    
    setRangeRpcTimeout in interface StorageProxyMBean
  - getTruncateRpcTimeout
```
public java.lang.Long getTruncateRpcTimeout()
```
    Specified by:
    
    getTruncateRpcTimeout in interface StorageProxyMBean
  - setTruncateRpcTimeout
```
public void setTruncateRpcTimeout(java.lang.Long timeoutInMillis)
```
    Specified by:
    
    setTruncateRpcTimeout in interface StorageProxyMBean
  - reloadTriggerClass
```
public void reloadTriggerClass()
```
    Specified by:
    
    reloadTriggerClass in interface StorageProxyMBean
  - getReadRepairAttempted
```
public long getReadRepairAttempted()
```
    Specified by:
    
    getReadRepairAttempted in interface StorageProxyMBean
  - getReadRepairRepairedBlocking
```
public long getReadRepairRepairedBlocking()
```
    Specified by:
    
    getReadRepairRepairedBlocking in interface StorageProxyMBean
  - getReadRepairRepairedBackground
```
public long getReadRepairRepairedBackground()
```
    Specified by:
    
    getReadRepairRepairedBackground in interface StorageProxyMBean

Class StorageProxy

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MBEAN_NAME

UNREACHABLE

instance

Method Detail

cas

mutate

mutateWithTriggers

mutateAtomically

performWrite

sendToHintedEndpoints

submitHint

writeHintForMutation

mutateCounter

applyCounterMutationOnLeader

applyCounterMutationOnCoordinator

read

getLiveSortedEndpoints

getRangeSlice

describeSchemaVersions

getReadOperations

getTotalReadLatencyMicros

getRecentReadLatencyMicros

getTotalReadLatencyHistogramMicros

getRecentReadLatencyHistogramMicros

getRangeOperations

getTotalRangeLatencyMicros

getRecentRangeLatencyMicros

getTotalRangeLatencyHistogramMicros

getRecentRangeLatencyHistogramMicros

getWriteOperations

getTotalWriteLatencyMicros

getRecentWriteLatencyMicros

getTotalWriteLatencyHistogramMicros

getRecentWriteLatencyHistogramMicros

getHintedHandoffEnabled

setHintedHandoffEnabled

getMaxHintWindow

setMaxHintWindow

shouldHint

truncateBlocking

getTotalHints

getMaxHintsInProgress

setMaxHintsInProgress

getHintsInProgress

verifyNoHintsInProgress

getRpcTimeout

setRpcTimeout

getReadRpcTimeout

setReadRpcTimeout

getWriteRpcTimeout

setWriteRpcTimeout

getCasContentionTimeout

setCasContentionTimeout

getRangeRpcTimeout

setRangeRpcTimeout

getTruncateRpcTimeout

setTruncateRpcTimeout

reloadTriggerClass

getReadRepairAttempted

getReadRepairRepairedBlocking

getReadRepairRepairedBackground