// Iterate all
ds.iterate(sessionId, accessResult -> {
    System.out.println(accessResult.getUrl());
    System.out.println(accessResult.getContent());
});

// Cleanup
ds.delete(sessionId);
```

### Resource Cleanup Pattern

```java
// Always use try-with-resources for ResponseData
try (ResponseData responseData = client.execute(requestData)) {
    // Process
}  // Temp files auto-deleted

        } finally {
            // Cleanup
            try {
                client.admin().indices().prepareDelete(suggester.getIndex() + "*").execute().actionGet();
            } catch (Exception cleanupError) {
                // Ignore cleanup errors
            }
            suggester.shutdown();
        }

        this.numOfThreads = numOfThreads;
        return this;
    }

    /**
     * Enables cleanup operations for this job.
     *
     * @return this job instance for method chaining
     */
    public GenerateThumbnailJob cleanup() {
        cleanup = true;
        return this;
    }

    @Override
    public String execute() {

     * This marks the access results as processed and clears the list.
     *
     * @param accessResultList the list of access results to clean up
     * @return the time taken for the cleanup operation in milliseconds, or -1 if no cleanup was needed
     */
    private long cleanupAccessResults(final List<OpenSearchAccessResult> accessResultList) {
        if (!accessResultList.isEmpty()) {

        protected int numOfThreads = 1;

        /**
         * Whether to run in cleanup mode to remove old thumbnails.
         */
        @Option(name = "-c", aliases = "--cleanup", usage = "Clean-Up mode")
        protected boolean cleanup;

        /**
         * Default constructor for command-line options.
         */
        protected Options() {

     * 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 {
            // TODO transaction?
            urlQueueService.delete(sessionId);

     * 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>
     *

import jakarta.annotation.Resource;

/**
 * A factory class for managing and creating crawler clients based on URL patterns.
 * This class implements AutoCloseable to properly handle resource cleanup.
 *
 * <p>The factory maintains a map of regular expression patterns to crawler clients,
 * allowing for URL-based client selection. Clients can be added with specific patterns

     * When enabled, only new or modified documents are crawled.
     */
    @Size(max = 10)
    public String incrementalCrawling;

    /**
     * Number of days to keep crawled documents before cleanup.
     * Set to -1 to disable automatic cleanup.
     */
    @Required
    @Min(-1)
    @Max(1000)
    @ValidateTypeFailure
    public Integer dayForCleanup;

    /**
     * Number of threads to use for crawling operations.

            assertEquals("Braces should be balanced", openBraces, closeBraces);
        }
    }

    /**
     * Test that InputStream is properly closed even when exception occurs.
     * Verifies try-with-resources cleanup behavior.
     */
    @Test
    public void testResourceLoading_exceptionHandling() {
        try {