import org.apache.cassandra.db.filter.TombstoneOverwhelmingException; //导入依赖的package包/类
public void doVerb(MessageIn<AbstractRangeCommand> message, int id)
{
    try
    {
        if (StorageService.instance.isBootstrapMode())
        {
            /* Don't service reads! */
            throw new RuntimeException("Cannot service reads while bootstrapping!");
        }
        RangeSliceReply reply = new RangeSliceReply(message.payload.executeLocally());
        Tracing.trace("Enqueuing response to {}", message.from);
        MessagingService.instance().sendReply(reply.createMessage(), id, message.from);
    }
    catch (TombstoneOverwhelmingException e)
    {
        // error already logged.  Drop the request
    }
    catch (Exception ex)
    {
        throw new RuntimeException(ex);
    }
}
 

import org.apache.cassandra.db.filter.TombstoneOverwhelmingException; //导入依赖的package包/类
public void doVerb(MessageIn<ReadCommand> message, int id)
{
    if (StorageService.instance.isBootstrapMode())
    {
        throw new RuntimeException("Cannot service reads while bootstrapping!");
    }

    ReadCommand command = message.payload;
    Keyspace keyspace = Keyspace.open(command.ksName);
    Row row;
    try
    {
        row = command.getRow(keyspace);
    }
    catch (TombstoneOverwhelmingException e)
    {
        // error already logged.  Drop the request
        return;
    }

    MessageOut<ReadResponse> reply = new MessageOut<ReadResponse>(MessagingService.Verb.REQUEST_RESPONSE,
                                                                  getResponse(command, row),
                                                                  ReadResponse.serializer);
    Tracing.trace("Enqueuing response to {}", message.from);
    MessagingService.instance().sendReply(reply, id, message.from);
}
 

import org.apache.cassandra.db.filter.TombstoneOverwhelmingException; //导入依赖的package包/类
protected void runMayThrow()
{
    try
    {
        try (ReadOrderGroup orderGroup = command.startOrderGroup(); UnfilteredPartitionIterator iterator = command.executeLocally(orderGroup))
        {
            handler.response(command.createResponse(iterator));
        }
        MessagingService.instance().addLatency(FBUtilities.getBroadcastAddress(), TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start));
    }
    catch (Throwable t)
    {
        handler.onFailure(FBUtilities.getBroadcastAddress());
        if (t instanceof TombstoneOverwhelmingException)
            logger.error(t.getMessage());
        else
            throw t;
    }
}
 

import org.apache.cassandra.db.filter.TombstoneOverwhelmingException; //导入依赖的package包/类
@Test
public void testBeyondThresholdSelect() throws Throwable
{
    createTable("CREATE TABLE %s (a text, b text, c text, PRIMARY KEY (a, b));");

    // insert exactly the amount of tombstones that *SHOULD* trigger an exception
    for (int i = 0; i < THRESHOLD + 1; i++)
        execute("INSERT INTO %s (a, b, c) VALUES ('key', 'column" + i + "', null);");

    try
    {
        execute("SELECT * FROM %s WHERE a = 'key';");
        fail("SELECT with tombstones beyond the threshold should have failed, but hasn't");
    }
    catch (Throwable e)
    {
        String error = "Expected exception instanceof TombstoneOverwhelmingException instead got "
                      + System.lineSeparator()
                      + Throwables.getStackTraceAsString(e);
        assertTrue(error, e instanceof TombstoneOverwhelmingException);
    }
}
 

import org.apache.cassandra.db.filter.TombstoneOverwhelmingException; //导入依赖的package包/类
public void run()
{
    MessagingService.Verb verb = message.verb;
    if (MessagingService.DROPPABLE_VERBS.contains(verb)
        && System.currentTimeMillis() > constructionTime + message.getTimeout())
    {
        MessagingService.instance().incrementDroppedMessages(verb, isCrossNodeTimestamp);
        return;
    }

    IVerbHandler verbHandler = MessagingService.instance().getVerbHandler(verb);
    if (verbHandler == null)
    {
        logger.trace("Unknown verb {}", verb);
        return;
    }

    try
    {
        verbHandler.doVerb(message, id);
    }
    catch (IOException ioe)
    {
        handleFailure(ioe);
        throw new RuntimeException(ioe);
    }
    catch (TombstoneOverwhelmingException | IndexNotAvailableException e)
    {
        handleFailure(e);
        logger.error(e.getMessage());
    }
    catch (Throwable t)
    {
        handleFailure(t);
        throw t;
    }

    if (GOSSIP_VERBS.contains(message.verb))
        Gossiper.instance.setLastProcessedMessageAt(constructionTime);
}