* documents and converting them into a key-value structure.
 *
 * <p>This interface extends {@link java.io.Closeable}, so implementations
 * should also handle resource cleanup when the {@link #close()} method is called.</p>
 */
public interface DocumentReader extends Closeable {
    /**
     * Reads a document and returns its contents as a map.
     *

        final UrlQueue<?> urlQueue = (UrlQueue<?>) objs[1];
        if (logger.isInfoEnabled()) {
            logger.info("Unsupported URL: {}", urlQueue.getUrl());
        }
    }

    /**
     * Processes cleanup crawling log events.
     *
     * @param objs the log objects
     */
    protected void processCleanupCrawling(final Object... objs) {
        // CrawlerContext crawlerContext = (CrawlerContext) objs[0];
    }

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

 * 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,
    /** Indicates an unsupported URL was encountered when crawling started. */
    UNSUPPORTED_URL_AT_CRAWLING_STARTED,

            }
        }
    }

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

 * </ul>
 *
 * <p>The container supports component initialization and destruction through consumer functions,
 * allowing custom setup and cleanup operations for components.
 *
 */
public class StandardCrawlerContainer implements CrawlerContainer {

    private static final Logger logger = LogManager.getLogger(StandardCrawlerContainer.class);

 *   <li>Object metadata and tags retrieval</li>
 *   <li>Directory listing capabilities</li>
 * </ul>
 *
 * <p>The client handles timeout management for access operations and includes proper
 * resource cleanup mechanisms.
 *
 */
public class StorageClient extends AbstractCrawlerClient {

    private static final Logger logger = LogManager.getLogger(StorageClient.class);

    /**

- **Rules**: Content processing rules and validation

## Building and Testing

### Build Commands

```bash
# Build all modules
mvn clean install

# Build without tests
mvn clean install -DskipTests

# Build specific module
mvn clean install -pl fess-crawler

# Generate test coverage report
mvn jacoco:report
```

### Code Quality

```bash
# Format code

        runner.ensureYellow();
    }

    @AfterClass
    public static void afterClass() throws Exception {
        runner.close();
        runner.clean();
    }

    @Before
    public void before() throws Exception {
        try {
            runner.admin().indices().prepareDelete("_all").execute().actionGet();
        } catch (IndexNotFoundException ignore) {

            CopyUtil.copy(is, fos);
        } catch (final Exception e) {
            CloseableUtil.closeQuietly(fos); // for deleting file
            FileUtil.deleteInBackground(tempFile); // clean up
            throw new CrawlingAccessException("Could not read a response body: " + responseData.getUrl(), e);
        } finally {
            CloseableUtil.closeQuietly(fos);
        }
        return tempFile;
    }