Java MessagingService类代码示例

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
/**
 * Deserialize a partition update from a provided byte buffer.
 *
 * @param bytes the byte buffer that contains the serialized update.
 * @param version the version with which the update is serialized.
 * @param key the partition key for the update. This is only used if {@code version &lt 3.0}
 * and can be {@code null} otherwise.
 *
 * @return the deserialized update or {@code null} if {@code bytes == null}.
 */
public static PartitionUpdate fromBytes(ByteBuffer bytes, int version, DecoratedKey key)
{
    if (bytes == null)
        return null;

    try
    {
        return serializer.deserialize(new DataInputBuffer(bytes, true),
                                      version,
                                      SerializationHelper.Flag.LOCAL,
                                      version < MessagingService.VERSION_30 ? key : null);
    }
    catch (IOException e)
    {
        throw new RuntimeException(e);
    }
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
Outcome await()
{
    long timeout = TimeUnit.MILLISECONDS.toNanos(DatabaseDescriptor.getTimeout(MessagingService.Verb.HINT)) - (System.nanoTime() - start);
    boolean timedOut;

    try
    {
        timedOut = !condition.await(timeout, TimeUnit.NANOSECONDS);
    }
    catch (InterruptedException e)
    {
        throw new AssertionError(e);
    }

    return timedOut ? Outcome.TIMEOUT : outcome;
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
public PrepareResponse deserialize(DataInputPlus in, int version) throws IOException
{
    boolean success = in.readBoolean();
    Commit inProgress = Commit.serializer.deserialize(in, version);
    Commit mostRecent;
    if (version < MessagingService.VERSION_30)
    {
        UUID ballot = UUIDSerializer.serializer.deserialize(in, version);
        PartitionUpdate update = PartitionUpdate.serializer.deserialize(in, version, SerializationHelper.Flag.LOCAL, inProgress.update.partitionKey());
        mostRecent = new Commit(ballot, update);
    }
    else
    {
        mostRecent = Commit.serializer.deserialize(in, version);
    }
    return new PrepareResponse(success, inProgress, mostRecent);
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
public synchronized void finishParentSession(UUID parentSession, Set<InetAddress> neighbors, boolean doAntiCompaction) throws InterruptedException, ExecutionException, IOException
{
    try
    {
        if (doAntiCompaction)
        {
            for (InetAddress neighbor : neighbors)
            {
                AnticompactionRequest acr = new AnticompactionRequest(parentSession);
                MessageOut<RepairMessage> req = acr.createMessage();
                MessagingService.instance().sendOneWay(req, neighbor);
            }
            List<Future<?>> futures = doAntiCompaction(parentSession);
            FBUtilities.waitOnFutures(futures);
        }
    }
    finally
    {
        parentRepairSessions.remove(parentSession);
    }
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
public static void asyncRemoveFromBatchlog(Collection<InetAddress> endpoints, UUID uuid)
{
    AbstractWriteResponseHandler<IMutation> handler = new WriteResponseHandler<>(endpoints,
                                                                                 Collections.<InetAddress>emptyList(),
                                                                                 ConsistencyLevel.ANY,
                                                                                 Keyspace.open(SystemKeyspace.NAME),
                                                                                 null,
                                                                                 WriteType.SIMPLE);
    Mutation mutation = getRemoveMutation(uuid);

    for (InetAddress target : endpoints)
    {
        logger.trace("Sending legacy batchlog remove request {} to {}", uuid, target);
        MessagingService.instance().sendRR(mutation.createMessage(MessagingService.Verb.MUTATION), target, handler, false);
    }
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的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.net.MessagingService; //导入依赖的package包/类
@Test
public void test() throws IOException
{
    InetAddress endpoint = InetAddress.getByName("127.0.0.1");
    int generation = 0;
    int maxVersion = 123;
    GossipDigest expected = new GossipDigest(endpoint, generation, maxVersion);
    //make sure we get the same values out
    assertEquals(endpoint, expected.getEndpoint());
    assertEquals(generation, expected.getGeneration());
    assertEquals(maxVersion, expected.getMaxVersion());

    //test the serialization and equals
    DataOutputBuffer output = new DataOutputBuffer();
    GossipDigest.serializer.serialize(expected, output, MessagingService.current_version);

    ByteArrayInputStream input = new ByteArrayInputStream(output.getData(), 0, output.getLength());
    GossipDigest actual = GossipDigest.serializer.deserialize(new DataInputStream(input), MessagingService.current_version);
    assertEquals(0, expected.compareTo(actual));
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
public void maybeTryAdditionalReplicas()
{
    // no latency information, or we're overloaded
    if (cfs.sampleLatencyNanos > TimeUnit.MILLISECONDS.toNanos(command.getTimeout()))
        return;

    if (!handler.await(cfs.sampleLatencyNanos, TimeUnit.NANOSECONDS))
    {
        // Could be waiting on the data, or on enough digests.
        ReadCommand retryCommand = command;
        if (handler.resolver.isDataPresent())
            retryCommand = command.copy().setIsDigestQuery(true);

        InetAddress extraReplica = Iterables.getLast(targetReplicas);
        if (traceState != null)
            traceState.trace("speculating read retry on {}", extraReplica);
        logger.trace("speculating read retry on {}", extraReplica);
        int version = MessagingService.instance().getVersion(extraReplica);
        MessagingService.instance().sendRRWithFailure(retryCommand.createMessage(version), extraReplica, handler);
        speculated = true;

        cfs.metric.speculativeRetries.inc();
    }
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
/**
 * Sends a notification to a node indicating we have finished replicating data.
 *
 * @param remote node to send notification to
 */
private void sendReplicationNotification(InetAddress remote)
{
    // notify the remote token
    MessageOut msg = new MessageOut(MessagingService.Verb.REPLICATION_FINISHED);
    IFailureDetector failureDetector = FailureDetector.instance;
    if (logger.isDebugEnabled())
        logger.debug("Notifying {} of replication completion\n", remote);
    while (failureDetector.isAlive(remote))
    {
        AsyncOneResponse iar = MessagingService.instance().sendRR(msg, remote);
        try
        {
            iar.get(DatabaseDescriptor.getRpcTimeout(), TimeUnit.MILLISECONDS);
            return; // done
        }
        catch(TimeoutException e)
        {
            // try again
        }
    }
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
public long serializedSize(RepairJobDesc desc, int version)
{
    int size = 0;
    if (version >= MessagingService.VERSION_21)
    {
        size += TypeSizes.sizeof(desc.parentSessionId != null);
        if (desc.parentSessionId != null)
            size += UUIDSerializer.serializer.serializedSize(desc.parentSessionId, version);
    }
    size += UUIDSerializer.serializer.serializedSize(desc.sessionId, version);
    size += TypeSizes.sizeof(desc.keyspace);
    size += TypeSizes.sizeof(desc.columnFamily);
    size += TypeSizes.sizeof(desc.ranges.size());
    for (Range<Token> rt : desc.ranges)
    {
        size += AbstractBounds.tokenSerializer.serializedSize(rt, version);
    }
    return size;
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的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.net.MessagingService; //导入依赖的package包/类
public void maybeTryAdditionalReplicas()
{
    // no latency information, or we're overloaded
    if (cfs.sampleLatencyNanos > TimeUnit.MILLISECONDS.toNanos(command.getTimeout()))
        return;

    if (!handler.await(cfs.sampleLatencyNanos, TimeUnit.NANOSECONDS))
    {
        // Could be waiting on the data, or on enough digests.
        ReadCommand retryCommand = command;
        if (resolver.getData() != null)
            retryCommand = command.copy().setIsDigestQuery(true);

        InetAddress extraReplica = Iterables.getLast(targetReplicas);
        logger.trace("speculating read retry on {}", extraReplica);
        MessagingService.instance().sendRR(retryCommand.createMessage(), extraReplica, handler);
        speculated = true;

        cfs.metric.speculativeRetries.inc();
    }
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
public static long getTimeout(MessagingService.Verb verb)
{
    switch (verb)
    {
        case READ:
            return getReadRpcTimeout();
        case RANGE_SLICE:
        case PAGED_RANGE:
            return getRangeRpcTimeout();
        case TRUNCATE:
            return getTruncateRpcTimeout();
        case READ_REPAIR:
        case MUTATION:
        case PAXOS_COMMIT:
        case PAXOS_PREPARE:
        case PAXOS_PROPOSE:
        case HINT:
        case BATCH_STORE:
        case BATCH_REMOVE:
            return getWriteRpcTimeout();
        case COUNTER_MUTATION:
            return getCounterWriteRpcTimeout();
        default:
            return getRpcTimeout();
    }
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
@Test
public void testSerializer() throws IOException
{
    long now = FBUtilities.timestampMicros();
    Mutation mutation = createMutation("testSerializer", now);
    Hint hint = Hint.create(mutation, now / 1000);

    // serialize
    int serializedSize = (int) Hint.serializer.serializedSize(hint, MessagingService.current_version);
    DataOutputBuffer dob = new DataOutputBuffer();
    Hint.serializer.serialize(hint, dob, MessagingService.current_version);
    assertEquals(serializedSize, dob.getLength());

    // deserialize
    DataInputPlus di = new DataInputBuffer(dob.buffer(), true);
    Hint deserializedHint = Hint.serializer.deserialize(di, MessagingService.current_version);

    // compare before/after
    assertHintsEqual(hint, deserializedHint);
}
 

import org.apache.cassandra.net.MessagingService; //导入依赖的package包/类
/**
 * Removes the endpoint from Gossip but retains endpoint state
 */
public void removeEndpoint(InetAddress endpoint)
{
    // do subscribers first so anything in the subscriber that depends on gossiper state won't get confused
    for (IEndpointStateChangeSubscriber subscriber : subscribers)
        subscriber.onRemove(endpoint);

    if(seeds.contains(endpoint))
    {
        buildSeedsList();
        seeds.remove(endpoint);
        logger.info("removed {} from seeds, updated seeds list = {}", endpoint, seeds);
    }

    liveEndpoints.remove(endpoint);
    unreachableEndpoints.remove(endpoint);
    // do not remove endpointState until the quarantine expires
    FailureDetector.instance.remove(endpoint);
    MessagingService.instance().resetVersion(endpoint);
    quarantineEndpoint(endpoint);
    MessagingService.instance().destroyConnectionPool(endpoint);
    if (logger.isDebugEnabled())
        logger.debug("removing endpoint {}", endpoint);
}