## 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
`static interface` `StorageProxy.WritePerformer`

Field Summary
`static StorageProxy` `instance`
`static java.lang.String` `UNREACHABLE`

Method Summary
`static IWriteResponseHandler` `applyCounterMutationOnCoordinator(CounterMutation cm, java.lang.String localDataCenter)`
`static IWriteResponseHandler` `applyCounterMutationOnLeader(CounterMutation cm, java.lang.String localDataCenter)`
`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()`
`static java.util.List<Row>` `getRangeSlice(RangeSliceCommand command, ConsistencyLevel consistency_level)`
`long` `getReadOperations()`
`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()`
`long` `getWriteOperations()`
`static void` `mutate(java.util.List<? extends IMutation> mutations, ConsistencyLevel consistency_level)` Use this method to have these Mutations applied across all replicas.
`static IWriteResponseHandler` `mutateCounter(CounterMutation cm, java.lang.String localDataCenter)` Handle counter mutation on the coordinator host.
`static IWriteResponseHandler` `performWrite(IMutation mutation, ConsistencyLevel consistency_level, java.lang.String localDataCenter, StorageProxy.WritePerformer performer)` 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 java.util.List<Row>` `scan(java.lang.String keyspace, java.lang.String column_family, IndexClause index_clause, SlicePredicate column_predicate, ConsistencyLevel consistency_level)`
`static java.util.concurrent.Future<java.lang.Void>` `scheduleLocalHint(RowMutation mutation, java.net.InetAddress target, IWriteResponseHandler responseHandler, ConsistencyLevel consistencyLevel)`
`static void` `sendToHintedEndpoints(RowMutation rm, java.util.Collection<java.net.InetAddress> targets, IWriteResponseHandler 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` `setRpcTimeout(java.lang.Long timeoutInMillis)`
`static boolean` `shouldHint(java.net.InetAddress ep)`
`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

### 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.List<? extends IMutation> mutations,
                              ConsistencyLevel consistency_level)
                       throws UnavailableException,
                              java.util.concurrent.TimeoutException

  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`
    `java.util.concurrent.TimeoutException`

### performWrite

    public static IWriteResponseHandler performWrite(IMutation mutation,
                                                     ConsistencyLevel consistency_level,
                                                     java.lang.String localDataCenter,
                                                     StorageProxy.WritePerformer performer)
                                              throws UnavailableException,
                                                     java.util.concurrent.TimeoutException,
                                                     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).
  Throws:
    `UnavailableException`
    `java.util.concurrent.TimeoutException`
    `java.io.IOException`

### sendToHintedEndpoints

    public static void sendToHintedEndpoints(RowMutation rm,
                                             java.util.Collection<java.net.InetAddress> targets,
                                             IWriteResponseHandler responseHandler,
                                             java.lang.String localDataCenter,
                                             ConsistencyLevel consistency_level)
                                      throws java.io.IOException,
                                             java.util.concurrent.TimeoutException

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

### scheduleLocalHint

    public static java.util.concurrent.Future<java.lang.Void> scheduleLocalHint(RowMutation mutation,
                                                                                java.net.InetAddress target,
                                                                                IWriteResponseHandler responseHandler,
                                                                                ConsistencyLevel consistencyLevel)
                                                                         throws java.io.IOException

  Throws:
    `java.io.IOException`

### mutateCounter

    public static IWriteResponseHandler mutateCounter(CounterMutation cm,
                                                      java.lang.String localDataCenter)
                                               throws UnavailableException,
                                                      java.util.concurrent.TimeoutException,
                                                      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`
    `java.util.concurrent.TimeoutException`
    `java.io.IOException`

### applyCounterMutationOnLeader

    public static IWriteResponseHandler applyCounterMutationOnLeader(CounterMutation cm,
                                                                     java.lang.String localDataCenter)
                                                              throws UnavailableException,
                                                                     java.util.concurrent.TimeoutException,
                                                                     java.io.IOException

  Throws:
    `UnavailableException`
    `java.util.concurrent.TimeoutException`
    `java.io.IOException`

### applyCounterMutationOnCoordinator

    public static IWriteResponseHandler applyCounterMutationOnCoordinator(CounterMutation cm,
                                                                          java.lang.String localDataCenter)
                                                                   throws UnavailableException,
                                                                          java.util.concurrent.TimeoutException,
                                                                          java.io.IOException

  Throws:
    `UnavailableException`
    `java.util.concurrent.TimeoutException`
    `java.io.IOException`

### read

    public static java.util.List<Row> read(java.util.List<ReadCommand> commands,
                                           ConsistencyLevel consistency_level)
                                    throws java.io.IOException,
                                           UnavailableException,
                                           java.util.concurrent.TimeoutException,
                                           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:
    `java.io.IOException`
    `UnavailableException`
    `java.util.concurrent.TimeoutException`
    `InvalidRequestException`

### getRangeSlice

    public static java.util.List<Row> getRangeSlice(RangeSliceCommand command,
                                                    ConsistencyLevel consistency_level)
                                             throws java.io.IOException,
                                                    UnavailableException,
                                                    java.util.concurrent.TimeoutException

  Throws:
    `java.io.IOException`
    `UnavailableException`
    `java.util.concurrent.TimeoutException`

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

### getTotalReadLatencyMicros

    public long getTotalReadLatencyMicros()

  Specified by:
    `getTotalReadLatencyMicros` in interface `StorageProxyMBean`

### getRecentReadLatencyMicros

    public double getRecentReadLatencyMicros()

  Specified by:
    `getRecentReadLatencyMicros` in interface `StorageProxyMBean`

### getTotalReadLatencyHistogramMicros

    public long[] getTotalReadLatencyHistogramMicros()

  Specified by:
    `getTotalReadLatencyHistogramMicros` in interface `StorageProxyMBean`

### getRecentReadLatencyHistogramMicros

    public long[] getRecentReadLatencyHistogramMicros()

  Specified by:
    `getRecentReadLatencyHistogramMicros` in interface `StorageProxyMBean`

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

### scan

    public static java.util.List<Row> scan(java.lang.String keyspace,
                                           java.lang.String column_family,
                                           IndexClause index_clause,
                                           SlicePredicate column_predicate,
                                           ConsistencyLevel consistency_level)
                                    throws java.io.IOException,
                                           java.util.concurrent.TimeoutException,
                                           UnavailableException

  Throws:
    `java.io.IOException`
    `java.util.concurrent.TimeoutException`
    `UnavailableException`

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

Copyright © 2012 The Apache Software Foundation