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,
	}
}

    }

    /**
     * Set the create time of the file. The time is specified as milliseconds
     * from Jan 1, 1970 which is the same as that which is returned by the
     * {@code createTime()} method.
     *
     * This method does not apply to workgroups, servers, or shares.
     *
     * @param time the create time as milliseconds since Jan 1, 1970
     * @throws SmbException if an error occurs while setting the create time

    try {
      CacheBuilder<Object, Object> builder =
          createCacheBuilder()
              .expireAfterWrite(100, MILLISECONDS)
              .refreshAfterWrite(5, MILLISECONDS)
              .ticker(ticker);

      CacheLoader<String, String> loader =
          new CacheLoader<String, String>() {
            @Override

    val response1 = getResponse(newRequest("/a"))
    response1.body
      .source()
      .timeout()
      .timeout(100, TimeUnit.MILLISECONDS)
    assertContent("This connection won't pool properly", response1)
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)

  fun timeoutsUpdatedOnReusedConnections() {
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(
      MockResponse
        .Builder()
        .body("def")
        .throttleBody(1, 750, TimeUnit.MILLISECONDS)
        .build(),
    )

    // First request: time out after 1s.
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofSeconds(1))
        .build()

    /**
     * Mask for attributes that can be set on the server
     */
    protected static final int ATTR_SET_MASK = 0x30A7;
    /**
     * Default expiration period for cached attributes in milliseconds
     */
    protected static final int DEFAULT_ATTR_EXPIRATION_PERIOD = 5000;

    /**
     * Hash code for the "." directory entry
     */
    protected static final int HASH_DOT = ".".hashCode();

         *
         * @param requestBuilder the request builder that was executed
         * @param execTime       the execution time in milliseconds
         * @param response       the optional response from the search engine
         * @return the built result object
         */
        T build(B requestBuilder, long execTime, OptionalEntity<R> response);

lid","score","configFromStringAndArray","createFromInputFallback","configFromString","dayOrDate","minute","second","millisecond","configFromObject","isUTC","add","prototypeMin","other","prototypeMax","pickBy","moments","ordering","Duration","duration","years","quarters","quarter","weeks","isoWeek","days","milliseconds","unitHasDecimal","parseFloat","isDurationValid","_milliseconds","_days","_months","_data","_bubble","isDuration","absRound","round","offset","separator","utcOffset","sign","offset...

	go func() {
		<-ctx.Done()
		globalNotificationSys.ServiceFreeze(ctx, false)
	}()

	keepAliveTicker := time.NewTicker(500 * time.Millisecond)
	defer keepAliveTicker.Stop()

	enc := json.NewEncoder(w)
	ch := objectSpeedTest(ctx, speedTestOpts{
		objectSize:       size,
		concurrencyStart: concurrent,
		duration:         duration,

					// Log if we took a lot of time.
					logger.Info("Site replication healing refresh took %.2fs", took)
				}

				// wait for 200 millisecond, if we are experience lot of I/O
				waitForLowIO(runtime.GOMAXPROCS(0), 200*time.Millisecond, currentHTTPIO)
			}
			healTimer.Reset(siteHealTimeInterval)

		case <-ctx.Done():
			return
		}
	}
}