*
     * @param responseData the response data containing the response body
     * @return a temporary file containing the response body
     * @throws CrawlingAccessException if an error occurs while reading the response body
     */
    public static File createResponseBodyFile(final ResponseData responseData) {
        File tempFile = null;
        FileOutputStream fos = null;

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

import org.codelibs.fess.crawler.exception.CrawlingAccessException;

/**
 * Exception thrown when an error occurs during data store crawling operations.
 * This exception provides information about the URL where the error occurred
 * and whether the crawling process should be aborted.
 */

     * This method extends the standard processing to include plugin JAR files that contain
     * the "Fess-WebAppJar" manifest attribute.
     *
     * @throws LifecycleException if an error occurs during processing
     */
    @Override
    protected void processWebInfLib() throws LifecycleException {
        super.processWebInfLib();

     * delayMillisBeforeProcessing parameter.
     *
     * @throws InterruptedRuntimeException if the thread is interrupted during the delay
     * @throws CrawlerSystemException if an error occurs while processing the URL
     */
    @Override
    protected void delayBeforeProcessing() {
        final UrlQueue<?> urlQueue = CrawlingParameterUtil.getUrlQueue();
        if (urlQueue == null) {
            return;

 * represents a valid sitemap. It uses a SitemapsHelper to validate the response body as an InputStream.
 * The rule checks if the URL matches the defined regex pattern and then validates the content as a sitemap.
 * If any exception occurs during the sitemap validation, it logs the error and returns false.
 *
 */
public class SitemapsRule extends RegexRule {
    /**
     * Serial version UID for serialization.
     */

	docker volume prune -f || true
	docker volume rm $(docker volume ls -q -f dangling=true) || true
}

verify_checksum_after_heal() {
	local sum1
	sum1=$(curl -s "$2" | sha256sum)
	mc admin heal --json -r "$1" >/dev/null # test after healing
	local sum1_heal
	sum1_heal=$(curl -s "$2" | sha256sum)

	if [ "${sum1_heal}" != "${sum1}" ]; then
		echo "mismatch expected ${sum1_heal}, got ${sum1}"
		exit 1
	fi
}

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.curl.Curl.Method;
import org.codelibs.curl.CurlRequest;
import org.codelibs.fesen.client.curl.FesenRequest;
import org.codelibs.fesen.client.node.NodeManager;
import org.codelibs.fess.mylasta.direction.FessConfig;
import org.codelibs.fess.util.ComponentUtil;

   * With regular request bodies it is not legal to write bytes to the sink passed to
   * [RequestBody.writeTo] after that method returns. For duplex requests bodies that condition is
   * lifted. Such writes occur on an application-provided thread and may occur concurrently with
   * reads of the [ResponseBody]. For duplex request bodies, [writeTo] should return
   * quickly, possibly by handing off the provided request body to another thread to perform
   * writing.

    /**
     * Checks if a bucket exists in the object storage.
     * @param name the name of the bucket to check
     * @return true if the bucket exists, false otherwise
     * @throws CrawlingAccessException if an error occurs while checking bucket existence
     */
    protected boolean bucketExists(final String name) {
        try {
            final BucketExistsArgs args = BucketExistsArgs.builder().bucket(name).build();

    exit 1
  fi
  sleep 1
done

pushd /tmp >/dev/null
git clone https://github.com/codelibs/fess-testdata.git
popd >/dev/null

cat ${temp_log_file} ./fess-*/logs/*.log
curl -s "http://localhost:9201/_cat/indices?v"