checkNotNull(runnable, "Runnable was null.");
    checkNotNull(executor, "Executor was null.");

    // Lock while we check state. We must maintain the lock while adding the new pair so that
    // another thread can't run the list out from under us. We only add to the list if we have not
    // yet started execution.
    synchronized (lock) {
      if (!executed) {

  <modules>
    <module>../inheritance</module>
  </modules>

  <!-- 5 urls in the pom to configure for not adding path -->
  <url>http://www.apache.org/path/to/parent/</url>
  <scm child.scm.connection.inherit.append.path="false"
       child.scm.developerConnection.inherit.append.path="false"

        If you have deleted your repo, please recreate it and publish a retraction.

        Retracting a module version involves adding a retract directive to your go.mod file and publishing a new version.
        For example: https://github.com/jba/retract-demo/blob/main/go.mod#L5-L8.

            shaFile.delete();
        }
    }

    private void createSha(File dependency, String jarName, File shaFile) throws IOException, NoSuchAlgorithmException {
        logger.lifecycle("Adding sha for " + jarName);

        String sha = parentTask.get().getSha1(dependency);

        Files.write(shaFile.toPath(), sha.getBytes(StandardCharsets.UTF_8), StandardOpenOption.CREATE);
    }

    @Internal

    @Override
    public void write(final int b) throws IOException {
        if (b == 0) {
            return;
        }
        if (b == '\n') {
            // always flush with newlines instead of adding to the buffer
            flush();
            return;
        }

        if (end == buffer.length) {
            if (start != 0) {

        // Test with empty strings
        result = jobExecutor.execute("", "");
        assertEquals("Executed:  ", result);
    }

    @Test
    public void test_addShutdownListener() {
        // Test adding shutdown listener
        AtomicBoolean shutdownCalled = new AtomicBoolean(false);
        ShutdownListener listener = new ShutdownListener() {
            @Override
            public void onShutdown() {

    )
    branch_name = f"fastapi-topic-repos-{secrets.token_hex(4)}"
    logging.info(f"Creating a new branch {branch_name}")
    subprocess.run(["git", "checkout", "-b", branch_name], check=True)
    logging.info("Adding updated file")
    subprocess.run(["git", "add", str(repos_path)], check=True)
    logging.info("Committing updated file")
    message = "👥 Update FastAPI GitHub topic repositories"

      pull-requests: write
    runs-on: ubuntu-latest
    steps:
    - uses: actions/labeler@v6
      if: ${{ github.event.action != 'labeled' && github.event.action != 'unlabeled' }}
    - run: echo "Done adding labels"
  # Run this after labeler applied labels
  check-labels:
    needs:
      - labeler
    permissions:
      pull-requests: read
    runs-on: ubuntu-latest
    steps:

containers provide isolated application execution environment, orchestration platforms allow seamless scaling by helping replicate and manage containers. MinIO extends this by adding isolated storage environment for each tenant.

MinIO is built ground up on the cloud-native premise. With features like erasure-coding, distributed and shared setup, it focuses only on storage and does it very well. While, it can be scaled by just replicating MinIO instances per tenant via an orchestration platform....

        if conf.await_label is None or (conf.await_label in pr_label_by_name):
            logging.debug(f"Processable PR: {pr.number}")
            if len(approved_reviews) >= conf.number:
                logging.info(f"Adding label to PR: {pr.number}")
                pr.add_to_labels(approved_label)
                if conf.await_label:
                    logging.info(f"Removing label from PR: {pr.number}")