var cancel context.CancelFunc
	ctx = setCaller(ctx, c.remote)
	if msg.DeadlineMS > 0 {
		ctx, cancel = context.WithTimeout(ctx, time.Duration(msg.DeadlineMS)*time.Millisecond)
	} else {
		ctx, cancel = context.WithCancel(ctx)
	}
	m := muxServer{
		ID:        msg.MuxID,
		RecvSeq:   msg.Seq + 1,
		SendSeq:   msg.Seq,
		ctx:       ctx,
		cancel:    cancel,
		parent:    c,

		Help:      "Maximum replication link latency in milliseconds seen since server uptime",
		Type:      gaugeMetric,
	}
}

func getClusterRepLinkLatencyAvgMD() MetricDescription {
	return MetricDescription{
		Namespace: nodeMetricNamespace,
		Subsystem: replicationSubsystem,
		Name:      avgLinkLatency,
		Help:      "Average replication link latency in milliseconds",
		Type:      gaugeMetric,
	}
}

    /**
     * Create a new handle reconnector with custom settings
     * @param manager the persistent handle manager
     * @param maxRetries maximum number of retry attempts
     * @param retryDelay base retry delay in milliseconds
     */
    public HandleReconnector(PersistentHandleManager manager, int maxRetries, long retryDelay) {
        this.handleManager = manager;
        this.maxRetries = maxRetries;
        this.retryDelay = retryDelay;

        .withExpireAfterWrites(
            ImmutableSet.of(
                // DurationSpec.of(500, MILLISECONDS),
                DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)))
        .withExpireAfterAccesses(
            ImmutableSet.of(
                // DurationSpec.of(500, MILLISECONDS),
                DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)))
        .withRefreshes(

            });

            waiter.start();
            Thread.sleep(50); // Give waiter time to start

            response.received();

            assertTrue(latch.await(500, TimeUnit.MILLISECONDS));
            assertTrue(response.isReceived());
        }

        @Test
        @DisplayName("Should handle async pending status")
        void testReceivedAsyncPending() throws InterruptedException {

framework.debug = false

# one day: 86400000, three days: 259200000, five days: 432000000, one week: 604800000, one year: 31556926000
# special script :: absolute mode: $(2014/07/10), relative mode: addDay(3).addMonth(4)
# The milliseconds for (relative or absolute) adjust time (set only when test) @LongType *dynamic in development
time.adjust.time.millis = 0

# ----------------------------------------------------------

| `minio_node_replication_max_link_latency_ms`            | Maximum replication link latency in milliseconds seen since server start                                 |
| `minio_node_replication_current_link_latency_ms`        | Current replication link latency in milliseconds                                                         |

import static com.google.common.util.concurrent.MoreExecutors.newDirectExecutorService;
import static com.google.common.util.concurrent.Runnables.doNothing;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.base.Predicate;

framework.debug = false

# one day: 86400000, three days: 259200000, five days: 432000000, one week: 604800000, one year: 31556926000
# special script :: absolute mode: $(2014/07/10), relative mode: addDay(3).addMonth(4)
# The milliseconds for (relative or absolute) adjust time (set only when test) @LongType *dynamic in development
time.adjust.time.millis = 0

# ----------------------------------------------------------

    /**
     * Get average response time
     *
     * @return average response time in milliseconds
     */
    public long getAverageResponseTime() {
        return avgResponseTime.get();
    }

    /**
     * Get 95th percentile response time
     *
     * @return 95th percentile response time in milliseconds
     */
    public long getP95ResponseTime() {
        return p95ResponseTime.get();
    }