StorageProxy (apache-cassandra API)
Date: 2018-02-14

org.apache.cassandra.service

## Class StorageProxy

- 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`

  - ### Field Summary

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

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `appliesLocally(Mutation mutation)`
    `static AbstractWriteResponseHandler<IMutation>` | `applyCounterMutationOnCoordinator(CounterMutation cm, java.lang.String localDataCenter, long queryStartNanoTime)`
    `static AbstractWriteResponseHandler<IMutation>` | `applyCounterMutationOnLeader(CounterMutation cm, java.lang.String localDataCenter, java.lang.Runnable callback, long queryStartNanoTime)`
    `static boolean` | `canDoLocalRequest(java.net.InetAddress replica)`
    `static RowIterator` | `cas(java.lang.String keyspaceName, java.lang.String cfName, DecoratedKey key, CASRequest request, ConsistencyLevel consistencyForPaxos, ConsistencyLevel consistencyForCommit, ClientState state, long queryStartNanoTime)` Apply @param updates if and only if the current values in the row for @param key match the provided @param conditions.
    `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.
    `void` | `disableHintsForDC(java.lang.String dc)`
    `void` | `enableHintsForDC(java.lang.String dc)`
    `java.lang.Long` | `getCasContentionTimeout()`
    `java.lang.Long` | `getCounterWriteRpcTimeout()`
    `java.util.Set<java.lang.String>` | `getHintedHandoffDisabledDCs()`
    `boolean` | `getHintedHandoffEnabled()`
    `int` | `getHintsInProgress()`
    `static java.util.List<java.net.InetAddress>` | `getLiveSortedEndpoints(Keyspace keyspace, java.nio.ByteBuffer key)`
    `static java.util.List<java.net.InetAddress>` | `getLiveSortedEndpoints(Keyspace keyspace, RingPosition pos)`
    `int` | `getMaxHintsInProgress()`
    `int` | `getMaxHintWindow()`
    `java.lang.Long` | `getNativeTransportMaxConcurrentConnections()`
    `java.lang.Long` | `getNativeTransportMaxConcurrentConnectionsPerIp()`
    `int` | `getNumberOfTables()`
    `int` | `getOtcBacklogExpirationInterval()`
    `java.lang.Long` | `getRangeRpcTimeout()`
    `static PartitionIterator` | `getRangeSlice(PartitionRangeReadCommand command, ConsistencyLevel consistencyLevel, long queryStartNanoTime)`
    `long` | `getReadRepairAttempted()`
    `long` | `getReadRepairRepairedBackground()`
    `long` | `getReadRepairRepairedBlocking()`
    `java.lang.Long` | `getReadRpcTimeout()`
    `java.lang.Long` | `getRpcTimeout()`
    `java.util.Map<java.lang.String,java.util.List<java.lang.String>>` | `getSchemaVersions()` Returns each live node's schema version
    `long` | `getTotalHints()`
    `java.lang.Long` | `getTruncateRpcTimeout()`
    `java.lang.Long` | `getWriteRpcTimeout()`
    `static void` | `mutate(java.util.Collection<? extends IMutation> mutations, ConsistencyLevel consistency_level, long queryStartNanoTime)` Use this method to have these Mutations applied across all replicas.
    `static void` | `mutateAtomically(java.util.Collection<Mutation> mutations, ConsistencyLevel consistency_level, boolean requireQuorumForRemove, long queryStartNanoTime)` See mutate.
    `static AbstractWriteResponseHandler<IMutation>` | `mutateCounter(CounterMutation cm, java.lang.String localDataCenter, long queryStartNanoTime)` Handle counter mutation on the coordinator host.
    `static void` | `mutateMV(java.nio.ByteBuffer dataKey, java.util.Collection<Mutation> mutations, boolean writeCommitLog, java.util.concurrent.atomic.AtomicLong baseComplete, long queryStartNanoTime)` Use this method to have these Mutations applied across all replicas.
    `static void` | `mutateWithTriggers(java.util.Collection<? extends IMutation> mutations, ConsistencyLevel consistencyLevel, boolean mutateAtomically, long queryStartNanoTime)`
    `static AbstractWriteResponseHandler<IMutation>` | `performWrite(IMutation mutation, ConsistencyLevel consistency_level, java.lang.String localDataCenter, StorageProxy.WritePerformer performer, java.lang.Runnable callback, WriteType writeType, long queryStartNanoTime)` Perform the write of a mutation given a WritePerformer.
    `static PartitionIterator` | `read(SinglePartitionReadCommand.Group group, ConsistencyLevel consistencyLevel, ClientState state, long queryStartNanoTime)` Performs the actual reading of a row out of the StorageService, fetching a specific set of column names from a given column family.
    `static PartitionIterator` | `read(SinglePartitionReadCommand.Group group, ConsistencyLevel consistencyLevel, long queryStartNanoTime)`
    `static RowIterator` | `readOne(SinglePartitionReadCommand command, ConsistencyLevel consistencyLevel, ClientState state, long queryStartNanoTime)`
    `static RowIterator` | `readOne(SinglePartitionReadCommand command, ConsistencyLevel consistencyLevel, long queryStartNanoTime)`
    `void` | `reloadTriggerClasses()`
    `static void` | `sendToHintedEndpoints(Mutation mutation, java.lang.Iterable<java.net.InetAddress> targets, AbstractWriteResponseHandler<IMutation> responseHandler, java.lang.String localDataCenter, Stage stage)` 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` | `setCounterWriteRpcTimeout(java.lang.Long timeoutInMillis)`
    `void` | `setHintedHandoffEnabled(boolean b)`
    `void` | `setMaxHintsInProgress(int qs)`
    `void` | `setMaxHintWindow(int ms)`
    `void` | `setNativeTransportMaxConcurrentConnections(java.lang.Long nativeTransportMaxConcurrentConnections)`
    `void` | `setNativeTransportMaxConcurrentConnectionsPerIp(java.lang.Long nativeTransportMaxConcurrentConnections)`
    `void` | `setOtcBacklogExpirationInterval(int intervalInMillis)`
    `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(Mutation mutation, java.util.Collection<java.net.InetAddress> targets, AbstractWriteResponseHandler<IMutation> responseHandler)`
    `static java.util.concurrent.Future<java.lang.Void>` | `submitHint(Mutation mutation, java.net.InetAddress target, AbstractWriteResponseHandler<IMutation> responseHandler)`
    `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()`

    - ### 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 RowIterator cas(java.lang.String keyspaceName,
                                        java.lang.String cfName,
                                        DecoratedKey key,
                                        CASRequest request,
                                        ConsistencyLevel consistencyForPaxos,
                                        ConsistencyLevel consistencyForCommit,
                                        ClientState state,
                                        long queryStartNanoTime)
                                 throws UnavailableException,
                                        IsBootstrappingException,
                                        RequestFailureException,
                                        RequestTimeoutException,
                                        InvalidRequestException

      Apply @param updates if and only if the current values in the row for @param key match the provided @param conditions. 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
        `request` - the conditions for the CAS to apply as well as the update to perform if the conditions hold.
        `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 corresponding to conditions. (since, if the CAS doesn't succeed, it means the current value do not match the conditions).
      Throws:
        `UnavailableException`
        `IsBootstrappingException`
        `RequestFailureException`
        `RequestTimeoutException`
        `InvalidRequestException`

    - #### mutate

          public static void mutate(java.util.Collection<? extends IMutation> mutations,
                                    ConsistencyLevel consistency_level,
                                    long queryStartNanoTime)
                             throws UnavailableException,
                                    OverloadedException,
                                    WriteTimeoutException,
                                    WriteFailureException

      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
        `queryStartNanoTime` - the value of System.nanoTime() when the query started to be processed
      Throws:
        `UnavailableException`
        `OverloadedException`
        `WriteTimeoutException`
        `WriteFailureException`

    - #### appliesLocally

          public boolean appliesLocally(Mutation mutation)

    - #### mutateMV

          public static void mutateMV(java.nio.ByteBuffer dataKey,
                                      java.util.Collection<Mutation> mutations,
                                      boolean writeCommitLog,
                                      java.util.concurrent.atomic.AtomicLong baseComplete,
                                      long queryStartNanoTime)
                               throws UnavailableException,
                                      OverloadedException,
                                      WriteTimeoutException

      Use this method to have these Mutations applied across all replicas.
      Parameters:
        `mutations` - the mutations to be applied across the replicas
        `writeCommitLog` - if commitlog should be written
        `baseComplete` - time from epoch in ms that the local base mutation was(or will be) completed
        `queryStartNanoTime` - the value of System.nanoTime() when the query started to be processed
      Throws:
        `UnavailableException`
        `OverloadedException`
        `WriteTimeoutException`

    - #### mutateWithTriggers

          public static void mutateWithTriggers(java.util.Collection<? extends IMutation> mutations,
                                                ConsistencyLevel consistencyLevel,
                                                boolean mutateAtomically,
                                                long queryStartNanoTime)
                                         throws WriteTimeoutException,
                                                WriteFailureException,
                                                UnavailableException,
                                                OverloadedException,
                                                InvalidRequestException

      Throws:
        `WriteTimeoutException`
        `WriteFailureException`
        `UnavailableException`
        `OverloadedException`
        `InvalidRequestException`

    - #### mutateAtomically

          public static void mutateAtomically(java.util.Collection<Mutation> mutations,
                                              ConsistencyLevel consistency_level,
                                              boolean requireQuorumForRemove,
                                              long queryStartNanoTime)
                                       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 Mutations to be applied across the replicas
        `consistency_level` - the consistency level for the operation
        `requireQuorumForRemove` - at least a quorum of nodes will see update before deleting batchlog
        `queryStartNanoTime` - the value of System.nanoTime() when the query started to be processed
      Throws:
        `UnavailableException`
        `OverloadedException`
        `WriteTimeoutException`

    - #### canDoLocalRequest

          public static boolean canDoLocalRequest(java.net.InetAddress replica)

    - #### performWrite

          public static AbstractWriteResponseHandler<IMutation> performWrite(IMutation mutation,
                                                                             ConsistencyLevel consistency_level,
                                                                             java.lang.String localDataCenter,
                                                                             StorageProxy.WritePerformer performer,
                                                                             java.lang.Runnable callback,
                                                                             WriteType writeType,
                                                                             long queryStartNanoTime)
                                                                      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
        `queryStartNanoTime` - the value of System.nanoTime() when the query started to be processed
      Throws:
        `UnavailableException`
        `OverloadedException`

    - #### sendToHintedEndpoints

          public static void sendToHintedEndpoints(Mutation mutation,
                                                   java.lang.Iterable<java.net.InetAddress> targets,
                                                   AbstractWriteResponseHandler<IMutation> responseHandler,
                                                   java.lang.String localDataCenter,
                                                   Stage stage)
                                            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:
        `OverloadedException` - if the hints cannot be written/enqueued

    - #### mutateCounter

          public static AbstractWriteResponseHandler<IMutation> mutateCounter(CounterMutation cm,
                                                                              java.lang.String localDataCenter,
                                                                              long queryStartNanoTime)
                                                                       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<IMutation> applyCounterMutationOnLeader(CounterMutation cm,
                                                                                             java.lang.String localDataCenter,
                                                                                             java.lang.Runnable callback,
                                                                                             long queryStartNanoTime)
                                                                                      throws UnavailableException,
                                                                                             OverloadedException

      Throws:
        `UnavailableException`
        `OverloadedException`

    - #### applyCounterMutationOnCoordinator

          public static AbstractWriteResponseHandler<IMutation> applyCounterMutationOnCoordinator(CounterMutation cm,
                                                                                                  java.lang.String localDataCenter,
                                                                                                  long queryStartNanoTime)
                                                                                           throws UnavailableException,
                                                                                                  OverloadedException

      Throws:
        `UnavailableException`
        `OverloadedException`

    - #### readOne

          public static RowIterator readOne(SinglePartitionReadCommand command,
                                            ConsistencyLevel consistencyLevel,
                                            long queryStartNanoTime)
                                     throws UnavailableException,
                                            IsBootstrappingException,
                                            ReadFailureException,
                                            ReadTimeoutException,
                                            InvalidRequestException

      Throws:
        `UnavailableException`
        `IsBootstrappingException`
        `ReadFailureException`
        `ReadTimeoutException`
        `InvalidRequestException`

    - #### readOne

          public static RowIterator readOne(SinglePartitionReadCommand command,
                                            ConsistencyLevel consistencyLevel,
                                            ClientState state,
                                            long queryStartNanoTime)
                                     throws UnavailableException,
                                            IsBootstrappingException,
                                            ReadFailureException,
                                            ReadTimeoutException,
                                            InvalidRequestException

      Throws:
        `UnavailableException`
        `IsBootstrappingException`
        `ReadFailureException`
        `ReadTimeoutException`
        `InvalidRequestException`

    - #### read

          public static PartitionIterator read(SinglePartitionReadCommand.Group group,
                                               ConsistencyLevel consistencyLevel,
                                               long queryStartNanoTime)
                                        throws UnavailableException,
                                               IsBootstrappingException,
                                               ReadFailureException,
                                               ReadTimeoutException,
                                               InvalidRequestException

      Throws:
        `UnavailableException`
        `IsBootstrappingException`
        `ReadFailureException`
        `ReadTimeoutException`
        `InvalidRequestException`

    - #### read

          public static PartitionIterator read(SinglePartitionReadCommand.Group group,
                                               ConsistencyLevel consistencyLevel,
                                               ClientState state,
                                               long queryStartNanoTime)
                                        throws UnavailableException,
                                               IsBootstrappingException,
                                               ReadFailureException,
                                               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`
        `ReadFailureException`
        `ReadTimeoutException`
        `InvalidRequestException`

    - #### getLiveSortedEndpoints

          public static java.util.List<java.net.InetAddress> getLiveSortedEndpoints(Keyspace keyspace,
                                                                                    java.nio.ByteBuffer key)

    - #### getLiveSortedEndpoints

          public static java.util.List<java.net.InetAddress> getLiveSortedEndpoints(Keyspace keyspace,
                                                                                    RingPosition pos)

    - #### getRangeSlice

          public static PartitionIterator getRangeSlice(PartitionRangeReadCommand command,
                                                        ConsistencyLevel consistencyLevel,
                                                        long queryStartNanoTime)

    - #### getSchemaVersions

          public java.util.Map<java.lang.String,java.util.List<java.lang.String>> getSchemaVersions()

      Description copied from interface: `StorageProxyMBean`
      Returns each live node's schema version
      Specified by:
        `getSchemaVersions` in interface `StorageProxyMBean`

    - #### 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.

    - #### getHintedHandoffEnabled

          public boolean getHintedHandoffEnabled()

      Specified by:
        `getHintedHandoffEnabled` in interface `StorageProxyMBean`

    - #### setHintedHandoffEnabled

          public void setHintedHandoffEnabled(boolean b)

      Specified by:
        `setHintedHandoffEnabled` in interface `StorageProxyMBean`

    - #### enableHintsForDC

          public void enableHintsForDC(java.lang.String dc)

      Specified by:
        `enableHintsForDC` in interface `StorageProxyMBean`

    - #### disableHintsForDC

          public void disableHintsForDC(java.lang.String dc)

      Specified by:
        `disableHintsForDC` in interface `StorageProxyMBean`

    - #### getHintedHandoffDisabledDCs

          public java.util.Set<java.lang.String> getHintedHandoffDisabledDCs()

      Specified by:
        `getHintedHandoffDisabledDCs` 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

      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`

    - #### 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()

    - #### submitHint

          public static java.util.concurrent.Future<java.lang.Void> submitHint(Mutation mutation,
                                                                               java.net.InetAddress target,
                                                                               AbstractWriteResponseHandler<IMutation> responseHandler)

    - #### submitHint

          public static java.util.concurrent.Future<java.lang.Void> submitHint(Mutation mutation,
                                                                               java.util.Collection<java.net.InetAddress> targets,
                                                                               AbstractWriteResponseHandler<IMutation> responseHandler)

    - #### 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`

    - #### getCounterWriteRpcTimeout

          public java.lang.Long getCounterWriteRpcTimeout()

      Specified by:
        `getCounterWriteRpcTimeout` in interface `StorageProxyMBean`

    - #### setCounterWriteRpcTimeout

          public void setCounterWriteRpcTimeout(java.lang.Long timeoutInMillis)

      Specified by:
        `setCounterWriteRpcTimeout` 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`

    - #### getNativeTransportMaxConcurrentConnections

          public java.lang.Long getNativeTransportMaxConcurrentConnections()

      Specified by:
        `getNativeTransportMaxConcurrentConnections` in interface `StorageProxyMBean`

    - #### setNativeTransportMaxConcurrentConnections

          public void setNativeTransportMaxConcurrentConnections(java.lang.Long nativeTransportMaxConcurrentConnections)

      Specified by:
        `setNativeTransportMaxConcurrentConnections` in interface `StorageProxyMBean`

    - #### getNativeTransportMaxConcurrentConnectionsPerIp

          public java.lang.Long getNativeTransportMaxConcurrentConnectionsPerIp()

    - #### setNativeTransportMaxConcurrentConnectionsPerIp

          public void setNativeTransportMaxConcurrentConnectionsPerIp(java.lang.Long nativeTransportMaxConcurrentConnections)

    - #### reloadTriggerClasses

          public void reloadTriggerClasses()

      Specified by:
        `reloadTriggerClasses` 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`

    - #### getNumberOfTables

          public int getNumberOfTables()

      Specified by:
        `getNumberOfTables` in interface `StorageProxyMBean`

    - #### getOtcBacklogExpirationInterval

          public int getOtcBacklogExpirationInterval()

      Specified by:
        `getOtcBacklogExpirationInterval` in interface `StorageProxyMBean`

    - #### setOtcBacklogExpirationInterval

          public void setOtcBacklogExpirationInterval(int intervalInMillis)

      Specified by:
        `setOtcBacklogExpirationInterval` in interface `StorageProxyMBean`

Copyright © 2018 The Apache Software Foundation