/**
     * Called when a chunk of the response is available during streaming.
     *
     * @param content the content chunk
     * @param done true if this is the final chunk
     */
    void onChunk(String content, boolean done);

    /**
     * Called when an error occurs during processing.
     *
     * @param phase the phase where the error occurred
     * @param error the error message

	docker-compose -f docker-compose-site1.yaml rm -s -f || true
	docker-compose -f docker-compose-site2.yaml rm -s -f || true
	for volume in $(docker volume ls -q | grep minio); do
		docker volume rm ${volume} || true
	done

	docker system prune -f || true
	docker volume prune -f || true
	docker volume rm $(docker volume ls -q -f dangling=true) || true
}

cleanup

if [ ! -f ./mc ]; then

		wg.Add(1)
		go func(ctx context.Context, peerChannel <-chan MetricV2, wg *sync.WaitGroup) {
			defer wg.Done()
			for {
				select {
				case m, ok := <-peerChannel:
					if !ok {
						return
					}
					select {
					case ch <- m:
					case <-ctx.Done():
						return
					}
				case <-ctx.Done():
					return
				}
			}
		}(ctx, peerChannels[index], &wg)
	}

	done := make(chan error)
	go func() {
		defer close(done)
		_, err := rb.Write([]byte("hello"))
		if err != nil {
			t.Errorf("got error: %q; expected none", err)
		}
		rb.CloseWriter()
		_, err = rb.Write([]byte("world"))
		done <- err
		err = rb.WriteByte(0)
		done <- err
		_, err = rb.TryWrite([]byte("world"))
		done <- err
		err = rb.TryWriteByte(0)
		done <- err
	}()

   */
  @CanIgnoreReturnValue
  protected final @Nullable T endOfData() {
    state = State.DONE;
    return null;
  }

  @Override
  public final boolean hasNext() {
    checkState(state != State.FAILED);
    switch (state) {
      case DONE:
        return false;
      case READY:
        return true;
      default:
    }
    return tryToComputeNext();
  }

	if res.ttl != noEvictionTTL {
		go func(done <-chan struct{}) {
			ticker := time.NewTicker(res.ttl / numBuckets)
			defer ticker.Stop()
			for {
				select {
				case <-done:
					return
				case <-ticker.C:
					res.deleteExpired()
				}
			}
		}(res.done)
	}
	return &res
}

// Purge clears the cache completely.

	for !errState {
		select {
		case <-m.ctx.Done():
			if debugPrint {
				fmt.Println("Client sending disconnect to mux", m.MuxID)
			}
			m.addErrorNonBlockingClose(errResp, context.Cause(m.ctx))
			errState = true
			continue
		case <-pingTimer:
			if !m.doPing(errResp) {
				errState = true
				continue
			}
		case req, ok := <-requests:
			if !ok {
				// Done send EOF
				if debugPrint {

				// Just wait for it to cancel.
				for blockResp {
					select {
					case <-ctx.Done():
						close(serverCanceled)
						return NewRemoteErr(ctx.Err())
					case resp <- []byte{1}:
						time.Sleep(10 * time.Millisecond)
					}
				}
				// Just wait for it to cancel.
				<-ctx.Done()
				close(serverCanceled)
				return NewRemoteErr(ctx.Err())
			},
			OutCapacity: 1,

		maxEntries = opts.count
	}

	done := false
	remaining := opts.count

	for !done {
		// Read up to max number of entries.
		fis, err := d.Readdir(maxEntries)
		if err != nil {
			if err == io.EOF {
				break
			}
			return nil, osErrToFileErr(err)
		}
		if opts.count > -1 {
			if remaining <= len(fis) {
				fis = fis[:remaining]
				done = true
			}
		}

  }

  /**
   * Retrieves the result of a {@code Future} known to be done but uses the {@code get(long,
   * TimeUnit)} overload in order to test that method.
   */
  static <V extends @Nullable Object> V getDoneFromTimeoutOverload(Future<V> future)
      throws ExecutionException {
    checkState(future.isDone(), "Future was expected to be done: %s", future);
    try {
      return getUninterruptibly(future, 0, SECONDS);