FROM golang:1.24-alpine as build

ARG TARGETARCH
ARG RELEASE

ENV GOPATH=/go
ENV CGO_ENABLED=0

# Install curl and minisign
RUN apk add -U --no-cache ca-certificates && \
    apk add -U --no-cache curl && \
    go install aead.dev/minisign/cmd/minisign@v0.2.1

# Download minio binary and signature files
RUN curl -s -q https://dl.min.io/server/minio/hotfixes/linux-${TARGETARCH}/archive/minio.${RELEASE} -o /go/bin/minio && \

   * <p>By default this method does nothing.
   */
  protected void startUp() throws Exception {}

  /**
   * Run the service. This method is invoked on the execution thread. Implementations must respond
   * to stop requests. You could poll for lifecycle changes in a work loop:
   *
   * <pre>
   *   public void run() {
   *     while ({@link #isRunning()}) {
   *       // perform a unit of work
   *     }
   *   }

```Dockerfile
FROM python:3.9

WORKDIR /code

COPY ./requirements.txt /code/requirements.txt

RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

COPY ./app /code/app

CMD ["fastapi", "run", "app/main.py", "--port", "80"]

# If running behind a proxy like Nginx or Traefik add --proxy-headers
# CMD ["fastapi", "run", "app/main.py", "--port", "80", "--proxy-headers"]
```

</details>

     * or queued.
     */
    @Nullable ExecutionSequencer sequencer;

    /**
     * Executor the task was set to run on. Set to null when the task has been queued, run, or
     * cancelled.
     */
    @Nullable Executor delegate;

    /**
     * Set before calling delegate.execute(); set to null once run, so that it can be GCed; this

                    public void some() {
                        Runnable anon = new Runnable() {
                            @Override
                            public void run() {}
                        };
                        anon.run();
                    }
                }
            """
        ) {
            assertEmptyReport()
        }
    }

    @Test

    val url = "https://dns.cloudflare.com/.not-so-well-known/run-dmc-query".toHttpUrl()
    val badProviders =
      listOf(
        DnsOverHttps
          .Builder()
          .client(bootstrapClient)
          .url(url)
          .post(true)
          .build(),
      )
    runBatch(badProviders, names)
    println("cached first run\n****************\n")
    names = listOf("google.com", "graph.facebook.com")

   * <p>By default this method does nothing.
   */
  protected void startUp() throws Exception {}

  /**
   * Run the service. This method is invoked on the execution thread. Implementations must respond
   * to stop requests. You could poll for lifecycle changes in a work loop:
   *
   * <pre>
   *   public void run() {
   *     while ({@link #isRunning()}) {
   *       // perform a unit of work
   *     }
   *   }

       *
       * This has the nice-ish side effect of limiting reentrancy: run() calls
       * timeoutFuture.setException() calls run(). That reentrancy would already be harmless, since
       * timeoutFuture can be set (and delegate cancelled) only once. (And "set only once" is
       * important for other reasons: run() can still be invoked concurrently in different threads,
       * even with the above null checks.)

          java-version: '17'
      - name: Install Groovy
        run: sudo apt-get install groovy
      - name: List PR commits
        run: |
          git log --pretty=format:"%H" ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }} > pr_commits.txt
      - name: Check PR commits
        id: run_check
        run: |
          groovy .github/workflows/CheckBadMerge.groovy pr_commits.txt > output.txt 2>&1

## Quick Start