}

    /**
     * Waits for the crawling process to terminate indefinitely.
     */
    public void awaitTermination() {
        awaitTermination(0);
    }

    /**
     * Waits for the crawling process to terminate for a specified duration.
     * @param millis The maximum time to wait in milliseconds. A value of 0 means wait indefinitely.
     */

      threadUnexpectedException(t);
    }
  }

  //     /**
  //      * Spin-waits up to LONG_DELAY_MS until flag becomes true.
  //      */
  //     public void await(AtomicBoolean flag) {
  //         await(flag, LONG_DELAY_MS);
  //     }

  //     /**
  //      * Spin-waits up to the specified timeout until flag becomes true.
  //      */

  /**
   * Converts the given ThreadPoolExecutor into an ExecutorService that exits when the application
   * is complete. It does so by using daemon threads and adding a shutdown hook to wait for their
   * completion.
   *
   * <p>This method waits 120 seconds before continuing with JVM termination, even if the executor
   * has not finished its work.
   *

 * The delay is calculated based on the configured delayMillisBeforeProcessing parameter.
 * If the time since the last request to the host is less than the configured delay,
 * the thread waits until the delay has elapsed.
 * This class is thread-safe.
 * The cache automatically evicts entries after 1 hour of inactivity to prevent memory leaks.
 */
public class HostIntervalController extends DefaultIntervalController {

                }
            }
        }

        /**
         * Waits for the crawling thread to terminate within a specified time limit.
         * This method blocks until the thread completes or the timeout expires.
         *
         * @param mills maximum time to wait in milliseconds
         */
        public void awaitTermination(final long mills) {
            try {

  /**
   * Asserts that a prior call that had caused this thread to block or wait has since returned
   * normally.
   */
  public void assertPriorCallReturns(@Nullable String methodName) throws Exception {
    assertEquals(null, getResponse(methodName).getResult());
  }

  /**
   * Asserts that a prior call that had caused this thread to block or wait has since returned the
   * expected boolean value.
   */

        // Default constructor
    }

    /** Wait time in milliseconds when crawler is not running */
    protected long crawlerWaitMillis = 10000;

    /** List of interval rules for controlling crawler timing */
    protected List<IntervalRule> ruleList = new ArrayList<>();

    /**
     * Checks the crawler status and waits if the crawler is not running.

  /**
   * Asserts that a prior call that had caused this thread to block or wait has since returned
   * normally.
   */
  public void assertPriorCallReturns(@Nullable String methodName) throws Exception {
    assertEquals(null, getResponse(methodName).getResult());
  }

  /**
   * Asserts that a prior call that had caused this thread to block or wait has since returned the
   * expected boolean value.
   */

     */
    public boolean connected() {
        return connected;
    }

    /**
     * Connects to the OpenSearch cluster.
     * Creates a new client and waits for cluster health to be yellow or better.
     */
    public void connect() {
        destroy();
        client = createClient();

            crawlingInfoHelper.putToInfoMap(key, dateFormat.format(new Date()));
        }
    }

    /**
     * Waits for a crawler thread to complete execution.
     * This method handles interruptions gracefully and logs when a crawler process is interrupted.
     *
     * @param crawlerThread the thread to wait for; null threads are ignored
     */
    private void joinCrawlerThread(final Thread crawlerThread) {