ALIAS_NAME=myminio
BUCKET="test-bucket"
SRC_DIR="/tmp/data"
INLINED_DIR="/tmp/inlined"
DEST_DIR="/tmp/dest"

TIMEOUT=10
while true; do
	if [[ ${TIMEOUT} -le 0 ]]; then
		echo retry: timeout while running: mc alias set
		exit 1
	fi
	eval ./mc alias set "${ALIAS_NAME}" "${MINIO_SERVER_URL}" minioadmin minioadmin && break
	TIMEOUT=$((TIMEOUT - 1))
	sleep 1
done

./mc ready "${ALIAS_NAME}"

./mc mb "${ALIAS_NAME}"/"${BUCKET}"

internal fun Source.skipAll(
  duration: Int,
  timeUnit: TimeUnit,
): Boolean {
  val nowNs = System.nanoTime()
  val originalDurationNs =
    if (timeout().hasDeadline()) {
      timeout().deadlineNanoTime() - nowNs
    } else {
      Long.MAX_VALUE
    }
  timeout().deadlineNanoTime(nowNs + minOf(originalDurationNs, timeUnit.toNanos(duration.toLong())))
  return try {
    val skipBuffer = Buffer()

  @Override
  protected abstract ExecutorService delegate();

  @CheckReturnValue
  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().awaitTermination(timeout, unit);
  }

  @Override
  public <T extends @Nullable Object> List<Future<T>> invokeAll(
      Collection<? extends Callable<T>> tasks) throws InterruptedException {

	if !drwm1.GetRLock(ctx1, cancel1, id, source, Options{Timeout: time.Second}) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("1st read lock acquired, waiting...")

	drwm2 := NewDRWMutex(ds, "simplelock")
	ctx2, cancel2 := context.WithCancel(t.Context())
	if !drwm2.GetRLock(ctx2, cancel2, id, source, Options{Timeout: time.Second}) {
		panic("Failed to acquire read lock")
	}

    this.session = session;
    this.notifyAll();
  }

  /** Waits for an OAuth session for this client to be set. */
  public synchronized void awaitAccessToken(Timeout timeout) throws InterruptedIOException {
    while (session == null) {
      timeout.waitUntilNotified(this);
    }
  }

  /** Starts a real time messaging session. */
  public void startRtm() throws IOException {
    String accessToken;

      throws InterruptedException {
    return drain(q, buffer, numElements, toNanosSaturated(timeout), NANOSECONDS);
  }

  /**
   * Drains the queue as {@link BlockingQueue#drainTo(Collection, int)}, but if the requested {@code
   * numElements} elements are not available, it will wait for them up to the specified timeout.
   *
   * @param q the blocking queue to be drained

  }

  @Throws(SocketException::class)
  override fun setSoLinger(
    on: Boolean,
    timeout: Int,
  ) {
    delegate!!.setSoLinger(on, timeout)
  }

  @Throws(SocketException::class)
  override fun setSoTimeout(timeout: Int) {
    delegate!!.soTimeout = timeout
  }

  @Throws(SocketException::class)
  override fun setTcpNoDelay(on: Boolean) {
    delegate!!.tcpNoDelay = on

    gradleTasks: String,
    os: Os = Os.LINUX,
    arch: Arch = Arch.AMD64,
    extraParameters: String = "",
    timeout: Int = 90,
    buildJvm: Jvm = BuildToolBuildJvm,
    extraSteps: BuildSteps.() -> Unit = {},
) {
    buildType.applyDefaultSettings(os, timeout = timeout, buildJvm = buildJvm)

    buildType.killProcessStep(KILL_LEAKED_PROCESSES_FROM_PREVIOUS_BUILDS, os)

  @Override
  protected abstract ExecutorService delegate();

  @CheckReturnValue
  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().awaitTermination(timeout, unit);
  }

  @Override
  public <T extends @Nullable Object> List<Future<T>> invokeAll(
      Collection<? extends Callable<T>> tasks) throws InterruptedException {

   *
   * @param timeout the maximum time to wait
   * @param unit the time unit of the timeout argument
   * @throws TimeoutException if not all of the services have stopped within the deadline
   */
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public void awaitStopped(long timeout, TimeUnit unit) throws TimeoutException {
    state.awaitStopped(timeout, unit);
  }

  /**