Java Tracing.traceRepair方法代码示例

import org.apache.cassandra.tracing.Tracing; //导入方法依赖的package包/类
/**
 * Receive merkle tree response or failed response from {@code endpoint} for current repair job.
 *
 * @param desc repair job description
 * @param endpoint endpoint that sent merkle tree
 * @param trees calculated merkle trees, or null if validation failed
 */
public void validationComplete(RepairJobDesc desc, InetAddress endpoint, MerkleTrees trees)
{
    ValidationTask task = validating.remove(Pair.create(desc, endpoint));
    if (task == null)
    {
        assert terminated;
        return;
    }

    String message = String.format("Received merkle tree for %s from %s", desc.columnFamily, endpoint);
    logger.info("[repair #{}] {}", getId(), message);
    Tracing.traceRepair(message);
    task.treesReceived(trees);

    // Unregister from FailureDetector once we've completed synchronizing Merkle trees.
    // After this point, we rely on tcp_keepalive for individual sockets to notify us when a connection is down.
    // See CASSANDRA-3569
    if (validationRemaining.decrementAndGet() == 0)
    {
        FailureDetector.instance.unregisterFailureDetectionEventListener(this);
    }
}
 

import org.apache.cassandra.tracing.Tracing; //导入方法依赖的package包/类
/**
 * Creates {@link ValidationTask} and submit them to task executor in parallel.
 *
 * @param endpoints Endpoint addresses to send validation request
 * @return Future that can get all {@link TreeResponse} from replica, if all validation succeed.
 */
private ListenableFuture<List<TreeResponse>> sendValidationRequest(Collection<InetAddress> endpoints)
{
    String message = String.format("Requesting merkle trees for %s (to %s)", desc.columnFamily, endpoints);
    logger.info("[repair #{}] {}", desc.sessionId, message);
    Tracing.traceRepair(message);
    int gcBefore = Keyspace.open(desc.keyspace).getColumnFamilyStore(desc.columnFamily).gcBefore(FBUtilities.nowInSeconds());
    List<ListenableFuture<TreeResponse>> tasks = new ArrayList<>(endpoints.size());
    for (InetAddress endpoint : endpoints)
    {
        ValidationTask task = new ValidationTask(desc, endpoint, gcBefore);
        tasks.add(task);
        session.waitForValidation(Pair.create(desc, endpoint), task);
        taskExecutor.execute(task);
    }
    return Futures.allAsList(tasks);
}
 

import org.apache.cassandra.tracing.Tracing; //导入方法依赖的package包/类
/**
 * Starts sending/receiving our list of differences to/from the remote endpoint: creates a callback
 * that will be called out of band once the streams complete.
 */
protected void startSync(List<Range<Token>> differences)
{
    InetAddress local = FBUtilities.getBroadcastAddress();
    // We can take anyone of the node as source or destination, however if one is localhost, we put at source to avoid a forwarding
    InetAddress dst = r2.endpoint.equals(local) ? r1.endpoint : r2.endpoint;
    InetAddress preferred = SystemKeyspace.getPreferredIP(dst);

    String message = String.format("Performing streaming repair of %d ranges with %s", differences.size(), dst);
    logger.info("[repair #{}] {}", desc.sessionId, message);
    boolean isIncremental = false;
    if (desc.parentSessionId != null)
    {
        ActiveRepairService.ParentRepairSession prs = ActiveRepairService.instance.getParentRepairSession(desc.parentSessionId);
        isIncremental = prs.isIncremental;
    }
    Tracing.traceRepair(message);
    new StreamPlan("Repair", repairedAt, 1, false, isIncremental).listeners(this)
                                        .flushBeforeTransfer(true)
                                        // request ranges from the remote node
                                        .requestRanges(dst, preferred, desc.keyspace, differences, desc.columnFamily)
                                        // send ranges to the remote node
                                        .transferRanges(dst, preferred, desc.keyspace, differences, desc.columnFamily)
                                        .execute();
}
 

import org.apache.cassandra.tracing.Tracing; //导入方法依赖的package包/类
/**
 * Compares trees, and triggers repairs for any ranges that mismatch.
 */
public void run()
{
    // compare trees, and collect differences
    List<Range<Token>> differences = MerkleTrees.difference(r1.trees, r2.trees);

    stat = new SyncStat(new NodePair(r1.endpoint, r2.endpoint), differences.size());

    // choose a repair method based on the significance of the difference
    String format = String.format("[repair #%s] Endpoints %s and %s %%s for %s", desc.sessionId, r1.endpoint, r2.endpoint, desc.columnFamily);
    if (differences.isEmpty())
    {
        logger.info(String.format(format, "are consistent"));
        Tracing.traceRepair("Endpoint {} is consistent with {} for {}", r1.endpoint, r2.endpoint, desc.columnFamily);
        set(stat);
        return;
    }

    // non-0 difference: perform streaming repair
    logger.info(String.format(format, "have " + differences.size() + " range(s) out of sync"));
    Tracing.traceRepair("Endpoint {} has {} range(s) out of sync with {} for {}", r1.endpoint, differences.size(), r2.endpoint, desc.columnFamily);
    startSync(differences);
}
 

import org.apache.cassandra.tracing.Tracing; //导入方法依赖的package包/类
/**
 * Called after the validation lifecycle to respond with the now valid tree. Runs in Stage.ANTIENTROPY.
 */
public void run()
{
    // respond to the request that triggered this validation
    if (!initiator.equals(FBUtilities.getBroadcastAddress()))
    {
        logger.info(String.format("[repair #%s] Sending completed merkle tree to %s for %s.%s", desc.sessionId, initiator, desc.keyspace, desc.columnFamily));
        Tracing.traceRepair("Sending completed merkle tree to {} for {}.{}", initiator, desc.keyspace, desc.columnFamily);
    }
    MessagingService.instance().sendOneWay(new ValidationComplete(desc, trees).createMessage(), initiator);
}
 

import org.apache.cassandra.tracing.Tracing; //导入方法依赖的package包/类
/**
 * Creates {@link ValidationTask} and submit them to task executor so that tasks run sequentially.
 */
private ListenableFuture<List<TreeResponse>> sendSequentialValidationRequest(Collection<InetAddress> endpoints)
{
    String message = String.format("Requesting merkle trees for %s (to %s)", desc.columnFamily, endpoints);
    logger.info("[repair #{}] {}", desc.sessionId, message);
    Tracing.traceRepair(message);
    int gcBefore = Keyspace.open(desc.keyspace).getColumnFamilyStore(desc.columnFamily).gcBefore(FBUtilities.nowInSeconds());
    List<ListenableFuture<TreeResponse>> tasks = new ArrayList<>(endpoints.size());

    Queue<InetAddress> requests = new LinkedList<>(endpoints);
    InetAddress address = requests.poll();
    ValidationTask firstTask = new ValidationTask(desc, address, gcBefore);
    logger.info("Validating {}", address);
    session.waitForValidation(Pair.create(desc, address), firstTask);
    tasks.add(firstTask);
    ValidationTask currentTask = firstTask;
    while (requests.size() > 0)
    {
        final InetAddress nextAddress = requests.poll();
        final ValidationTask nextTask = new ValidationTask(desc, nextAddress, gcBefore);
        tasks.add(nextTask);
        Futures.addCallback(currentTask, new FutureCallback<TreeResponse>()
        {
            public void onSuccess(TreeResponse result)
            {
                logger.info("Validating {}", nextAddress);
                session.waitForValidation(Pair.create(desc, nextAddress), nextTask);
                taskExecutor.execute(nextTask);
            }

            // failure is handled at root of job chain
            public void onFailure(Throwable t) {}
        });
        currentTask = nextTask;
    }
    // start running tasks
    taskExecutor.execute(firstTask);
    return Futures.allAsList(tasks);
}
 

import org.apache.cassandra.tracing.Tracing; //导入方法依赖的package包/类
public void onSuccess(StreamState result)
{
    String message = String.format("Sync complete using session %s between %s and %s on %s", desc.sessionId, r1.endpoint, r2.endpoint, desc.columnFamily);
    logger.info("[repair #{}] {}", desc.sessionId, message);
    Tracing.traceRepair(message);
    set(stat);
}
 

import org.apache.cassandra.tracing.Tracing; //导入方法依赖的package包/类
protected void startSync(List<Range<Token>> differences)
{
    InetAddress local = FBUtilities.getBroadcastAddress();
    SyncRequest request = new SyncRequest(desc, local, r1.endpoint, r2.endpoint, differences);
    String message = String.format("Forwarding streaming repair of %d ranges to %s (to be streamed with %s)", request.ranges.size(), request.src, request.dst);
    logger.info("[repair #{}] {}", desc.sessionId, message);
    Tracing.traceRepair(message);
    MessagingService.instance().sendOneWay(request.createMessage(), request.src);
}
 

import org.apache.cassandra.tracing.Tracing; //导入方法依赖的package包/类
/**
 * Start RepairJob on given ColumnFamilies.
 *
 * This first validates if all replica are available, and if they are,
 * creates RepairJobs and submit to run on given executor.
 *
 * @param executor Executor to run validation
 */
public void start(ListeningExecutorService executor)
{
    String message;
    if (terminated)
        return;

    logger.info(String.format("[repair #%s] new session: will sync %s on range %s for %s.%s", getId(), repairedNodes(), ranges, keyspace, Arrays.toString(cfnames)));
    Tracing.traceRepair("Syncing range {}", ranges);
    SystemDistributedKeyspace.startRepairs(getId(), parentRepairSession, keyspace, cfnames, ranges, endpoints);

    if (endpoints.isEmpty())
    {
        logger.info("[repair #{}] {}", getId(), message = String.format("No neighbors to repair with on range %s: session completed", ranges));
        Tracing.traceRepair(message);
        set(new RepairSessionResult(id, keyspace, ranges, Lists.<RepairResult>newArrayList()));
        SystemDistributedKeyspace.failRepairs(getId(), keyspace, cfnames, new RuntimeException(message));
        return;
    }

    // Checking all nodes are live
    for (InetAddress endpoint : endpoints)
    {
        if (!FailureDetector.instance.isAlive(endpoint))
        {
            message = String.format("Cannot proceed on repair because a neighbor (%s) is dead: session failed", endpoint);
            logger.error("[repair #{}] {}", getId(), message);
            Exception e = new IOException(message);
            setException(e);
            SystemDistributedKeyspace.failRepairs(getId(), keyspace, cfnames, e);
            return;
        }
    }

    // Create and submit RepairJob for each ColumnFamily
    List<ListenableFuture<RepairResult>> jobs = new ArrayList<>(cfnames.length);
    for (String cfname : cfnames)
    {
        RepairJob job = new RepairJob(this, cfname);
        executor.execute(job);
        jobs.add(job);
    }

    // When all RepairJobs are done without error, cleanup and set the final result
    Futures.addCallback(Futures.allAsList(jobs), new FutureCallback<List<RepairResult>>()
    {
        public void onSuccess(List<RepairResult> results)
        {
            // this repair session is completed
            logger.info("[repair #{}] {}", getId(), "Session completed successfully");
            Tracing.traceRepair("Completed sync of range {}", ranges);
            set(new RepairSessionResult(id, keyspace, ranges, results));

            taskExecutor.shutdown();
            // mark this session as terminated
            terminate();
        }

        public void onFailure(Throwable t)
        {
            logger.error(String.format("[repair #%s] Session completed with the following error", getId()), t);
            Tracing.traceRepair("Session completed with the following error: {}", t);
            forceShutdown(t);
        }
    });
}
 

import org.apache.cassandra.tracing.Tracing; //导入方法依赖的package包/类
/**
 * Creates {@link ValidationTask} and submit them to task executor so that tasks run sequentially within each dc.
 */
private ListenableFuture<List<TreeResponse>> sendDCAwareValidationRequest(Collection<InetAddress> endpoints)
{
    String message = String.format("Requesting merkle trees for %s (to %s)", desc.columnFamily, endpoints);
    logger.info("[repair #{}] {}", desc.sessionId, message);
    Tracing.traceRepair(message);
    int gcBefore = Keyspace.open(desc.keyspace).getColumnFamilyStore(desc.columnFamily).gcBefore(FBUtilities.nowInSeconds());
    List<ListenableFuture<TreeResponse>> tasks = new ArrayList<>(endpoints.size());

    Map<String, Queue<InetAddress>> requestsByDatacenter = new HashMap<>();
    for (InetAddress endpoint : endpoints)
    {
        String dc = DatabaseDescriptor.getEndpointSnitch().getDatacenter(endpoint);
        Queue<InetAddress> queue = requestsByDatacenter.get(dc);
        if (queue == null)
        {
            queue = new LinkedList<>();
            requestsByDatacenter.put(dc, queue);
        }
        queue.add(endpoint);
    }

    for (Map.Entry<String, Queue<InetAddress>> entry : requestsByDatacenter.entrySet())
    {
        Queue<InetAddress> requests = entry.getValue();
        InetAddress address = requests.poll();
        ValidationTask firstTask = new ValidationTask(desc, address, gcBefore);
        logger.info("Validating {}", address);
        session.waitForValidation(Pair.create(desc, address), firstTask);
        tasks.add(firstTask);
        ValidationTask currentTask = firstTask;
        while (requests.size() > 0)
        {
            final InetAddress nextAddress = requests.poll();
            final ValidationTask nextTask = new ValidationTask(desc, nextAddress, gcBefore);
            tasks.add(nextTask);
            Futures.addCallback(currentTask, new FutureCallback<TreeResponse>()
            {
                public void onSuccess(TreeResponse result)
                {
                    logger.info("Validating {}", nextAddress);
                    session.waitForValidation(Pair.create(desc, nextAddress), nextTask);
                    taskExecutor.execute(nextTask);
                }

                // failure is handled at root of job chain
                public void onFailure(Throwable t) {}
            });
            currentTask = nextTask;
        }
        // start running tasks
        taskExecutor.execute(firstTask);
    }
    return Futures.allAsList(tasks);
}