Java AbstractReplicationStrategy.getWriteResponseHandler方法代码示例

import org.apache.cassandra.locator.AbstractReplicationStrategy; //导入方法依赖的package包/类
/**
 * 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.
 *
 * @param mutation the mutation to be applied
 * @param consistency_level the consistency level for the write operation
 * @param 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).
 * @param callback an optional callback to be run if and when the write is
 * successful.
 */
public static AbstractWriteResponseHandler performWrite(IMutation mutation,
                                                        ConsistencyLevel consistency_level,
                                                        String localDataCenter,
                                                        WritePerformer performer,
                                                        Runnable callback,
                                                        WriteType writeType)
throws UnavailableException, OverloadedException
{
    String keyspaceName = mutation.getKeyspaceName();
    AbstractReplicationStrategy rs = Keyspace.open(keyspaceName).getReplicationStrategy();

    Token tk = StorageService.getPartitioner().getToken(mutation.key());
    List<InetAddress> naturalEndpoints = StorageService.instance.getNaturalEndpoints(keyspaceName, tk);
    Collection<InetAddress> pendingEndpoints = StorageService.instance.getTokenMetadata().pendingEndpointsFor(tk, keyspaceName);

    AbstractWriteResponseHandler responseHandler = rs.getWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, callback, writeType);

    // exit early if we can't fulfill the CL at this time
    responseHandler.assureSufficientLiveNodes();

    performer.apply(mutation, Iterables.concat(naturalEndpoints, pendingEndpoints), responseHandler, localDataCenter, consistency_level);
    return responseHandler;
}
 

import org.apache.cassandra.locator.AbstractReplicationStrategy; //导入方法依赖的package包/类
private static void commitPaxos(Commit proposal, ConsistencyLevel consistencyLevel) throws WriteTimeoutException
{
    Keyspace keyspace = Keyspace.open(proposal.update.metadata().ksName);

    Token tk = StorageService.getPartitioner().getToken(proposal.key);
    List<InetAddress> naturalEndpoints = StorageService.instance.getNaturalEndpoints(keyspace.getName(), tk);
    Collection<InetAddress> pendingEndpoints = StorageService.instance.getTokenMetadata().pendingEndpointsFor(tk, keyspace.getName());

    AbstractReplicationStrategy rs = keyspace.getReplicationStrategy();
    AbstractWriteResponseHandler responseHandler = rs.getWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistencyLevel, null, WriteType.SIMPLE);

    MessageOut<Commit> message = new MessageOut<Commit>(MessagingService.Verb.PAXOS_COMMIT, proposal, Commit.serializer);
    for (InetAddress destination : Iterables.concat(naturalEndpoints, pendingEndpoints))
    {
        if (FailureDetector.instance.isAlive(destination))
            MessagingService.instance().sendRR(message, destination, responseHandler);
    }

    responseHandler.get();
}
 

import org.apache.cassandra.locator.AbstractReplicationStrategy; //导入方法依赖的package包/类
/**
 * 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.
 *
 * @param mutation the mutation to be applied
 * @param consistency_level the consistency level for the write operation
 * @param 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).
 * @param callback an optional callback to be run if and when the write is
 * successful.
 */
public static AbstractWriteResponseHandler performWrite(IMutation mutation,
                                                        ConsistencyLevel consistency_level,
                                                        String localDataCenter,
                                                        WritePerformer performer,
                                                        Runnable callback,
                                                        WriteType writeType)
throws UnavailableException, OverloadedException, IOException
{
    String table = mutation.getTable();
    AbstractReplicationStrategy rs = Table.open(table).getReplicationStrategy();

    Token tk = StorageService.getPartitioner().getToken(mutation.key());
    List<InetAddress> naturalEndpoints = StorageService.instance.getNaturalEndpoints(table, tk);
    Collection<InetAddress> pendingEndpoints = StorageService.instance.getTokenMetadata().pendingEndpointsFor(tk, table);

    AbstractWriteResponseHandler responseHandler = rs.getWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, callback, writeType);

    // exit early if we can't fulfill the CL at this time
    responseHandler.assureSufficientLiveNodes();

    performer.apply(mutation, Iterables.concat(naturalEndpoints, pendingEndpoints), responseHandler, localDataCenter, consistency_level);
    return responseHandler;
}
 

import org.apache.cassandra.locator.AbstractReplicationStrategy; //导入方法依赖的package包/类
private static void commitPaxos(Commit proposal, ConsistencyLevel consistencyLevel) throws WriteTimeoutException
{
    boolean shouldBlock = consistencyLevel != ConsistencyLevel.ANY;
    Keyspace keyspace = Keyspace.open(proposal.update.metadata().ksName);

    Token tk = StorageService.getPartitioner().getToken(proposal.key);
    List<InetAddress> naturalEndpoints = StorageService.instance.getNaturalEndpoints(keyspace.getName(), tk);
    Collection<InetAddress> pendingEndpoints = StorageService.instance.getTokenMetadata().pendingEndpointsFor(tk, keyspace.getName());

    AbstractWriteResponseHandler responseHandler = null;
    if (shouldBlock)
    {
        AbstractReplicationStrategy rs = keyspace.getReplicationStrategy();
        responseHandler = rs.getWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistencyLevel, null, WriteType.SIMPLE);
    }

    MessageOut<Commit> message = new MessageOut<Commit>(MessagingService.Verb.PAXOS_COMMIT, proposal, Commit.serializer);
    for (InetAddress destination : Iterables.concat(naturalEndpoints, pendingEndpoints))
    {
        if (FailureDetector.instance.isAlive(destination))
        {
            if (shouldBlock)
                MessagingService.instance().sendRR(message, destination, responseHandler);
            else
                MessagingService.instance().sendOneWay(message, destination);
        }
    }

    if (shouldBlock)
        responseHandler.get();
}
 

import org.apache.cassandra.locator.AbstractReplicationStrategy; //导入方法依赖的package包/类
private static WriteResponseHandlerWrapper wrapResponseHandler(Mutation mutation, ConsistencyLevel consistency_level, WriteType writeType)
{
    AbstractReplicationStrategy rs = Keyspace.open(mutation.getKeyspaceName()).getReplicationStrategy();
    String keyspaceName = mutation.getKeyspaceName();
    Token tk = StorageService.getPartitioner().getToken(mutation.key());
    List<InetAddress> naturalEndpoints = StorageService.instance.getNaturalEndpoints(keyspaceName, tk);
    Collection<InetAddress> pendingEndpoints = StorageService.instance.getTokenMetadata().pendingEndpointsFor(tk, keyspaceName);
    AbstractWriteResponseHandler responseHandler = rs.getWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, null, writeType);
    return new WriteResponseHandlerWrapper(responseHandler, mutation);
}
 

import org.apache.cassandra.locator.AbstractReplicationStrategy; //导入方法依赖的package包/类
private static WriteResponseHandlerWrapper wrapResponseHandler(RowMutation mutation, ConsistencyLevel consistency_level, WriteType writeType)
{
    AbstractReplicationStrategy rs = Keyspace.open(mutation.getKeyspaceName()).getReplicationStrategy();
    String keyspaceName = mutation.getKeyspaceName();
    Token tk = StorageService.getPartitioner().getToken(mutation.key());
    List<InetAddress> naturalEndpoints = StorageService.instance.getNaturalEndpoints(keyspaceName, tk);
    Collection<InetAddress> pendingEndpoints = StorageService.instance.getTokenMetadata().pendingEndpointsFor(tk, keyspaceName);
    AbstractWriteResponseHandler responseHandler = rs.getWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, null, writeType);
    return new WriteResponseHandlerWrapper(responseHandler, mutation);
}
 

import org.apache.cassandra.locator.AbstractReplicationStrategy; //导入方法依赖的package包/类
private static WriteResponseHandlerWrapper wrapResponseHandler(RowMutation mutation, ConsistencyLevel consistency_level, WriteType writeType)
{
    AbstractReplicationStrategy rs = Table.open(mutation.getTable()).getReplicationStrategy();
    String table = mutation.getTable();
    Token tk = StorageService.getPartitioner().getToken(mutation.key());
    List<InetAddress> naturalEndpoints = StorageService.instance.getNaturalEndpoints(table, tk);
    Collection<InetAddress> pendingEndpoints = StorageService.instance.getTokenMetadata().pendingEndpointsFor(tk, table);
    AbstractWriteResponseHandler responseHandler = rs.getWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistency_level, null, writeType);
    return new WriteResponseHandlerWrapper(responseHandler, mutation);
}