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

    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 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.
    `boolean` | `getHintedHandoffEnabled()`
    `int` | `getHintsInProgress()`
    `int` | `getMaxHintsInProgress()`
    `int` | `getMaxHintWindow()`
    `long` | `getRangeOperations()`
    `java.lang.Long` | `getRangeRpcTimeout()`
    `static java.util.List<Row>` | `getRangeSlice(RangeSliceCommand 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()`
    `java.util.Map<java.lang.String,java.util.List<java.lang.String>>` | `getSchemaVersions()` Returns each live node's schema version
    `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 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.
    `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` | `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

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

    - #### 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,
                                                                  java.io.IOException

      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`
        `java.io.IOException`

    - #### 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:
        `OverloadedException` - if the hints cannot be written/enqueued

    - #### 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)
                                           throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### mutateCounter

          public static AbstractWriteResponseHandler mutateCounter(CounterMutation cm,
                                                   java.lang.String localDataCenter)
                                                            throws UnavailableException,
                                                                   OverloadedException,
                                                                   java.io.IOException

      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`
        `java.io.IOException`

    - #### applyCounterMutationOnLeader

          public static AbstractWriteResponseHandler applyCounterMutationOnLeader(CounterMutation cm,
                                                                  java.lang.String localDataCenter,
                                                                  java.lang.Runnable callback)
                                                                           throws UnavailableException,
                                                                                  java.io.IOException,
                                                                                  OverloadedException

      Throws:
        `UnavailableException`
        `java.io.IOException`
        `OverloadedException`

    - #### applyCounterMutationOnCoordinator

          public static AbstractWriteResponseHandler applyCounterMutationOnCoordinator(CounterMutation cm,
                                                                       java.lang.String localDataCenter)
                                                                                throws UnavailableException,
                                                                                       java.io.IOException,
                                                                                       OverloadedException

      Throws:
        `UnavailableException`
        `java.io.IOException`
        `OverloadedException`

    - #### read

          public static java.util.List<Row> read(java.util.List<ReadCommand> commands,
                                 ConsistencyLevel consistency_level)
                                          throws UnavailableException,
                                                 IsBootstrappingException,
                                                 ReadTimeoutException

      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`

    - #### getRangeSlice

          public static java.util.List<Row> getRangeSlice(RangeSliceCommand command,
                                          ConsistencyLevel consistency_level)
                                                   throws UnavailableException,
                                                          ReadTimeoutException

      Throws:
        `UnavailableException`
        `ReadTimeoutException`

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

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

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

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

Copyright © 2014 The Apache Software Foundation