import org.apache.cassandra.service.StorageProxy.LocalReadRunnable; //导入依赖的package包/类
private void makeRequests(ReadCommand readCommand, Iterable<InetAddress> endpoints)
{
    MessageOut<ReadCommand> message = null;
    boolean hasLocalEndpoint = false;

    for (InetAddress endpoint : endpoints)
    {
        if (isLocalRequest(endpoint))
        {
            hasLocalEndpoint = true;
            continue;
        }

        logger.trace("reading {} from {}", readCommand.isDigestQuery() ? "digest" : "data", endpoint);
        if (message == null)
            message = readCommand.createMessage();
        MessagingService.instance().sendRR(message, endpoint, handler);
    }

    // We delay the local (potentially blocking) read till the end to avoid stalling remote requests.
    if (hasLocalEndpoint)
    {
        logger.trace("reading {} locally", readCommand.isDigestQuery() ? "digest" : "data");
        StageManager.getStage(Stage.READ).maybeExecuteImmediately(new LocalReadRunnable(command, handler));
    }
}
 

import org.apache.cassandra.service.StorageProxy.LocalReadRunnable; //导入依赖的package包/类
protected void makeDataRequests(Iterable<InetAddress> endpoints)
{
    for (InetAddress endpoint : endpoints)
    {
        if (isLocalRequest(endpoint))
        {
            logger.trace("reading data locally");
            StageManager.getStage(Stage.READ).execute(new LocalReadRunnable(command, handler));
        }
        else
        {
            logger.trace("reading data from {}", endpoint);
            MessagingService.instance().sendRR(command.createMessage(), endpoint, handler);
        }
    }
}
 

import org.apache.cassandra.service.StorageProxy.LocalReadRunnable; //导入依赖的package包/类
protected void makeDigestRequests(Iterable<InetAddress> endpoints)
{
    ReadCommand digestCommand = command.copy();
    digestCommand.setDigestQuery(true);
    MessageOut<?> message = digestCommand.createMessage();
    for (InetAddress endpoint : endpoints)
    {
        if (isLocalRequest(endpoint))
        {
            logger.trace("reading digest locally");
            StageManager.getStage(Stage.READ).execute(new LocalReadRunnable(digestCommand, handler));
        }
        else
        {
            logger.trace("reading digest from {}", endpoint);
            MessagingService.instance().sendRR(message, endpoint, handler);
        }
    }
}
 

import org.apache.cassandra.service.StorageProxy.LocalReadRunnable; //导入依赖的package包/类
private void makeRequests(ReadCommand readCommand, Iterable<InetAddress> endpoints)
{
    boolean hasLocalEndpoint = false;

    for (InetAddress endpoint : endpoints)
    {
        if (StorageProxy.canDoLocalRequest(endpoint))
        {
            hasLocalEndpoint = true;
            continue;
        }

        if (traceState != null)
            traceState.trace("reading {} from {}", readCommand.isDigestQuery() ? "digest" : "data", endpoint);
        logger.trace("reading {} from {}", readCommand.isDigestQuery() ? "digest" : "data", endpoint);
        MessageOut<ReadCommand> message = readCommand.createMessage(MessagingService.instance().getVersion(endpoint));
        MessagingService.instance().sendRRWithFailure(message, endpoint, handler);
    }

    // We delay the local (potentially blocking) read till the end to avoid stalling remote requests.
    if (hasLocalEndpoint)
    {
        logger.trace("reading {} locally", readCommand.isDigestQuery() ? "digest" : "data");
        StageManager.getStage(Stage.READ).maybeExecuteImmediately(new LocalReadRunnable(command, handler));
    }
}
 

import org.apache.cassandra.service.StorageProxy.LocalReadRunnable; //导入依赖的package包/类
protected void makeDataRequests(Iterable<InetAddress> endpoints)
{
    boolean readLocal = false;
    for (InetAddress endpoint : endpoints)
    {    		
        if (isLocalRequest(endpoint))
        {
            readLocal = true;
        }
        else
        {
            logger.trace("reading data from {}", endpoint);
            logger.info("reading data from {}", endpoint);
            
            //@daidong I just 'assumed' that this remote request will be handled in the similar fashion
            //@daidong Actually, this assumption is true. All the requests are processed using StageManager. 
            //listed below. 
            MessagingService.instance().sendRR(command.createMessage(), endpoint, handler);
        }
    }
    if (readLocal)
    {
        logger.trace("reading data locally");
        logger.info("reading data locally");
        
        //@daidong Here is the code how we execute the Read request. There are several stages for each command.
        //@daidong For read, the Stage implementation is "multiThreadedLowSignalStage", which is a TracingAwareExecutorService
        logger.info("@daidong debug: " + "read data from local");
        StageManager.getStage(Stage.READ).maybeExecuteImmediately(new LocalReadRunnable(command, handler));
    }
}