MC_CONFIG_DIR="{{ .Values.configPathmc }}"
MC="/usr/bin/mc --insecure --config-dir ${MC_CONFIG_DIR}"
{{- else }}
MC="/usr/bin/mc --insecure"
{{- end }}

# connectToMinio
# Use a check-sleep-check loop to wait for MinIO service to be available
connectToMinio() {
  SCHEME=$1
  ATTEMPTS=0 ; LIMIT=29 ; # Allow 30 attempts
  set -e ; # fail if we can't read the keys.

# This script will not and should not be executed in the self hosted runner

echo "script failed" >resiliency-initial.log # assume initial state

echo "sleep to wait for MinIO Server to be ready prior mc commands"
# https://github.com/minio/mc/issues/3599

MINIO_SERVER_URL="http://127.0.0.1:9000"
ALIAS_NAME=myminio
BUCKET="test-bucket"
SRC_DIR="/tmp/data"
INLINED_DIR="/tmp/inlined"

import java.io.Closeable

/** Handler for mock server requests. */
public abstract class Dispatcher : Closeable {
  /**
   * Returns a response to satisfy `request`. This method may block (for instance, to wait on
   * a CountdownLatch).
   */
  @Throws(InterruptedException::class)
  public abstract fun dispatch(request: RecordedRequest): MockResponse

  /**

MinIO server allows to throttle incoming requests:

- limit the number of active requests allowed across the cluster
- limit the wait duration for each request in the queue

These values are enabled using server's configuration or environment variables.

## Examples

### Configuring connection limit

            final byte[] buf = new byte[1024];

            for (int ii = 0; ii < numIter; ii++) {

                synchronized (this) {
                    ltime = System.currentTimeMillis();
                    wait();
                }

                try {
                    final double r = Math.random();
                    if (r < 0.333) {
                        f.exists();

			if val := globalServiceFreeze.Load(); val != nil {
				if unlock, ok := val.(chan struct{}); ok && unlock != nil {
					// Wait until unfrozen.
					select {
					case <-unlock:
					case <-r.Context().Done():
						// if client canceled we don't need to wait here forever.
						return
					}
				}
			}
		}

		globalHTTPStats.addRequestsInQueue(1)

     */
    protected long reloadInterval = 1000L;

    /**
     * Update the configuration.
     */
    public void update() {
        CommonPoolUtil.execute(this::load);
    }

    /**
     * Wait for the next reloading.
     */
    protected void waitForNext() {
        if (reloadInterval > 0) {
            ThreadUtil.sleep(reloadInterval);
        }
    }

    /**
     * Load the configuration.

@REM
@REM   JAVA_HOME           (Optional) Points to a Java installation.
@REM   MAVEN_BATCH_ECHO    (Optional) Set to 'on' to enable the echoing of the batch commands.
@REM   MAVEN_BATCH_PAUSE   (Optional) set to 'on' to wait for a key stroke before ending.
@REM   MAVEN_OPTS          (Optional) Java runtime options used when Maven is executed.
@REM   MAVEN_SKIP_RC       (Optional) Flag to disable loading of mavenrc files.

        HandleInfo durableInfo = new HandleInfo("/test/file.txt", testGuid, testFileId, HandleType.DURABLE_V2, 100, // 100ms timeout
                null);

        assertFalse(durableInfo.isExpired());

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        assertTrue(durableInfo.isExpired());

          i.remove()
          return recordedResponse
        }
      }
      val nowMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime())
      if (nowMillis >= timeoutMillis) break
      (this as Object).wait(timeoutMillis - nowMillis)
    }

    throw AssertionError("Timed out waiting for response to $url")
  }

  companion object {
    val TIMEOUT_MILLIS = TimeUnit.SECONDS.toMillis(10)
  }