}

	// Last sanity check
	if len(tracker.QueuedBuckets) > 0 {
		return fmt.Errorf("not all buckets were healed: %v", tracker.QueuedBuckets)
	}

	return nil
}

func healBucket(bucket string, scan madmin.HealScanMode) error {
	// Get background heal sequence to send elements to heal
	bgSeq, ok := globalBackgroundHealState.getHealSequenceByToken(bgHealingUUID)
	if ok {

						tillOffset, DefaultBitrotAlgorithm, erasure.ShardSize())
				}
			}

			// Heal each part. erasure.Heal() will write the healed
			// part to .minio/tmp/uuid/ which needs to be renamed
			// later to the final location.
			err = erasure.Heal(ctx, writers, readers, partSize, prefer)
			closeBitrotReaders(readers)
			closeErrs := closeBitrotWriters(writers)
			if err != nil {

  /**
   * Waits for the {@link ServiceManager} to become {@linkplain #isHealthy() healthy}. The manager
   * will become healthy after all the component services have reached the {@linkplain State#RUNNING
   * running} state.
   *
   * @throws IllegalStateException if the service manager reaches a state from which it cannot
   *     become {@linkplain #isHealthy() healthy}.
   */
  public void awaitHealthy() {
    state.awaitHealthy();
  }

     * @throws NoAvailableChannelException if no healthy channels available
     */
    public ChannelInfo selectChannel(CommonServerMessageBlock message) throws NoAvailableChannelException {
        Collection<ChannelInfo> availableChannels = manager.getHealthyChannels();

        if (availableChannels.isEmpty()) {
            throw new NoAvailableChannelException("No healthy channels available");
        }

	EnvDriveWorkers = "MINIO_HEAL_DRIVE_WORKERS"
)

var configMutex sync.RWMutex

// Config represents the heal settings.
type Config struct {
	// Bitrot will perform bitrot scan on local disk when checking objects.
	Bitrot string `json:"bitrotscan"`

	// maximum sleep duration between objects to slow down heal operation.
	Sleep   time.Duration `json:"sleep"`
	IOCount int           `json:"iocount"`

    }
  }

  private fun makeSimpleCall() {
    server.enqueue(MockResponse(body = "healthy"))
    val callB = client.newCall(Request(server.url("/")))
    callB.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("healthy")
    }
  }

  private fun enableProtocol(protocol: Protocol) {
    enableTls()
    client =
      client

    // Make sure this connection is healthy & eligible for new exchanges. If it's no longer needed
    // then we're on the hook to close it.
    val healthy = candidate.isHealthy(doExtensiveHealthChecks)
    var noNewExchangesEvent = false
    val toClose: Socket? =
      candidate.withLock {
        when {
          !healthy -> {
            noNewExchangesEvent = !candidate.noNewExchanges

			XferStats:       mx,
		}
		epHealth, ok := epMap[v.Endpoint]
		if ok {
			metric.Endpoint = epHealth.Endpoint
			metric.TotalDowntime = epHealth.offlineDuration
			metric.LastOnline = epHealth.lastOnline
			metric.Online = epHealth.Online
			metric.Latency = madmin.LatencyStat{
				Curr: epHealth.latency.curr,
				Avg:  epHealth.latency.avg,
				Max:  epHealth.latency.peak,
			}
		}
		m[dID] = metric

        when(mockRequest.getTreeId()).thenReturn(123);

        // Should throw NoAvailableChannelException when no healthy channels
        assertThrows(ChannelLoadBalancer.NoAvailableChannelException.class, () -> loadBalancer.selectChannel(mockRequest),
                "Should throw exception when no healthy channels available");
    }

     */
    public long getIdleTime() {
        return System.currentTimeMillis() - lastActivityTime;
    }

    /**
     * Check if channel is in healthy state
     *
     * @return true if healthy
     */
    public boolean isHealthy() {
        return state == ChannelState.ACTIVE || state == ChannelState.ESTABLISHED;
    }

    /**
     * Get channel binding hash
     *