#   make release

    - name: Perform CodeQL Analysis
      uses: github/codeql-action/analyze@v4
      with:
        config-file: ./.github/codeql/codeql-config.yml

    - name: Cleanup Gradle Cache
      # Cleans up the Gradle caches before being cached
      run: |
        rm -f ~/.gradle/caches/modules-2/modules-2.lock
        rm -f ~/.gradle/caches/modules-2/gc.properties

/**
 * Define clean up rules for the project.
 * See https://www.jetbrains.com/help/teamcity/teamcity-data-clean-up.html#Clean-up+Rules
 *
 * @param historyDays days number of days to store build history .
 * @param artifactsDays number of days to store artifacts. In the stored history, artifacts older than this number will be cleaned up.

                    // Release the tree connection if possible
                    log.debug("Releasing tree connection during emergency cleanup");
                }
            } catch (Exception e) {
                log.debug("Error releasing tree connection during emergency cleanup", e);
            }

            // Note: resourceLoc is final, cannot be set to null
            // Clear other mutable references would go here

     * monitors their progress, and handles cleanup operations.
     *
     * <p>The method:</p>
     * <ul>
     *   <li>Creates crawler threads for each data configuration</li>
     *   <li>Manages concurrent execution based on thread count limits</li>
     *   <li>Monitors thread completion and handles cleanup</li>
     *   <li>Records execution timing and statistics</li>
     * </ul>
     *

                                } catch (Exception e) {
                                    // Ignore cleanup errors
                                }
                            });
                } catch (Exception e) {
                    // Ignore cleanup errors
                }
            }
        }
    }

    @Nested
    @DisplayName("Integration with AbstractUpgradeGoal")

            }
        }
    }

    /**
     * Cleans up the crawled data for a given session.
     * Deletes URL queue data and access result data, and clears the URL filter.
     * @param sessionId The session ID to clean up.
     */
    public void cleanup(final String sessionId) {
        if (logger.isInfoEnabled()) {
            logger.info("Starting crawler cleanup: sessionId={}", sessionId);
        }
        try {

#!/bin/bash

set -x

## change working directory
cd .github/workflows/multipart/

function cleanup() {
	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

        // Guava Cache handles expiration automatically
        // Wait for cache to expire and call cleanup
        try {
            Thread.sleep(100L);
        } catch (final InterruptedException e) {
            // ignore
        }

        rateLimitHelper.cleanup();
        // After cleanup, the expired entry should be removed
        // Note: The actual expiration depends on the configured block duration

#!/usr/bin/env bash

# shellcheck disable=SC2120
exit_1() {
	cleanup

	echo "minio1 ============"
	cat /tmp/minio1_1.log
	echo "minio2 ============"
	cat /tmp/minio2_1.log

	exit 1
}

cleanup() {
	echo -n "Cleaning up instances of MinIO ..."
	pkill minio || sudo pkill minio
	pkill -9 minio || sudo pkill -9 minio
	rm -rf /tmp/minio{1,2}
	echo "done"
}

cleanup

export MINIO_CI_CD=1
export MINIO_BROWSER=off

* Other dependencies need their results (it's a sub-dependency)
* The logic can be shared by multiple endpoints to do things like error early, authentication, etc.
* They need to handle cleanup (e.g., DB sessions, file handles), using dependencies with `yield`
* Their logic needs input data from the request, like headers, query parameters, etc.

## Dependencies with `yield` and `scope`