statusMap.put(CrawlerStatus.RUNNING, "In progress");
        statusMap.put(CrawlerStatus.DONE, "Completed");

        // Verify entries
        assertEquals(3, statusMap.size());
        assertEquals("Starting up", statusMap.get(CrawlerStatus.INITIALIZING));
        assertEquals("In progress", statusMap.get(CrawlerStatus.RUNNING));

crawler.setBackground(true);
String sessionId = crawler.execute();

// Check crawling status
while (crawler.crawlerContext.getStatus() == CrawlerStatus.RUNNING) {
    Thread.sleep(1000);
    System.out.println("Crawling in progress...");
}

// Wait for completion
crawler.awaitTermination();
System.out.println("Crawling completed");
```

### Custom Content Extractor

```java

        // Start crawling
        crawlerContext.setStatus(CrawlerStatus.RUNNING);
        crawlerContext.setActiveThreadCount(5);

        // Simulate crawling progress
        for (int i = 0; i < 100; i++) {
            crawlerContext.incrementAndGetAccessCount();
            crawlerContext.getRobotsTxtUrlSet().add("http://site" + i + ".com/robots.txt");
        }

            if (!ignoreException) {
                throw new CrawlerSystemException("Could not stop a process.", e);
            }
        }
    }

    /**
     * Delays the crawling process before processing a URL.
     */
    protected abstract void delayBeforeProcessing();

    /**
     * Delays the crawling process after processing a URL.
     */
    protected abstract void delayAfterProcessing();

    /**

        private final Process process;

        private final long timeout;

        private boolean finished = false;

        private boolean teminated = false;

        /**
         * Constructs a new MonitorThread.
         * @param process The process to monitor.
         * @param timeout The timeout for the process.
         */

package org.codelibs.fess.crawler.log;

/**
 * LogType defines the different types of log messages that can be generated during the crawling process.
 * Each enum constant represents a specific event or state in the crawler's execution.
 */
public enum LogType {
    /** Indicates the start of a crawling process. */
    START_CRAWLING,
    /** Indicates the cleanup phase of crawling. */
    CLEANUP_CRAWLING,

        super();
    }

    /**
     * Processes the given response data.
     * This implementation does nothing.
     *
     * @param responseData the response data to process
     */
    @Override
    public void process(final ResponseData responseData) {
        // do nothing
    }

 *   <li>Handling exceptions that may occur during the crawling process.</li>
 * </ol>
 *
 * <p>
 * The thread also manages the active thread count using {@code crawlerContext.activeThreadCountLock}
 * and provides methods for logging messages using {@link LogHelper}.
 * </p>
 *
 * <p>
 * The crawling process continues until the crawler status is {@link CrawlerStatus#DONE} or the

        super();
    }

    /**
     * Processes the given response data, extracting URLs from sitemaps.
     * @param responseData The response data.
     */
    @Override
    public void process(final ResponseData responseData) {
        final SitemapsHelper sitemapsHelper = crawlerContainer.getComponent("sitemapsHelper");
        try (final InputStream responseBody = responseData.getResponseBody()) {

 * It encapsulates the process of extracting data from an input stream using a specified or detected extractor.
 * The builder allows setting parameters such as MIME type, filename, extractor name, maximum content length,
 * and cache file size to optimize the extraction process.
 *
 * <p>
 * The main purpose of this class is to simplify the extraction process by providing a fluent interface