final CountDownLatch hasConfirmedIsRunning = new CountDownLatch(1);

    /*
     * The main test thread tries to stop() the service shortly after
     * confirming that it is running. Meanwhile, the service itself is trying
     * to confirm that it is running. If the main thread's stop() call happens
     * before it has the chance, the test will fail. To avoid this, the main

            startAsyncNotification(handle);

        } catch (Exception e) {
            log.error("Failed to start directory watching for: " + directoryPath, e);
        }
    }

    /**
     * Stop watching a directory
     *
     * @param directoryPath directory path
     */
    public void stopWatching(String directoryPath) {
        ChangeNotificationHandle handle = activeWatchers.remove(directoryPath);

            minDelayNanos = minOf(candidateDelay, minDelayNanos)
            continue@eachQueue
          }

          // If we already have more than one task, that's enough work for now. Stop searching.
          readyTask != null -> {
            multipleReadyTasks = true
            break@eachQueue
          }

          // We have a task to execute when we complete the loop.
          else -> {

                    .desc("Warn if checksums don't match")
                    .get());
            options.addOption(Option.builder(FAIL_FAST)
                    .longOpt("fail-fast")
                    .desc("Stop at first failure in reactorized builds")
                    .get());
            options.addOption(Option.builder(FAIL_AT_END)
                    .longOpt("fail-at-end")

		return err
	}
	// Delete the event from store.
	return h.store.Del(key)
}

// Cancel - cancels the target
func (h *Target) Cancel() {
	// If queuestore is configured, cancel it's context to
	// stop the replay go-routine.
	if h.store != nil {
		h.storeCtxCancel()
	}

	// Set logch to nil and close it.
	// This will block all Send operations,
	// and finish the existing ones.

    }

    /**
     * Checks if the system is in a force-stop state.
     *
     * @return true if the system is force-stopping, false otherwise.
     */
    public boolean isForceStop() {
        return forceStop.get();
    }

    /**
     * Sets the force-stop state of the system.
     *
     * @param b true to force-stop the system.
     */
    public void setForceStop(final boolean b) {

        }
    }

    /**
     * Forces all crawlers to stop immediately.
     * Sets the force stop flag and stops all active crawler instances.
     */
    private void forceStop() {
        systemHelper.setForceStop(true);
        if (crawlerList != null) {
            for (final Crawler crawler : crawlerList) {
                crawler.stop();
            }
        }
    }

    /**

#     treated as '${Hostname}' itself on the command line.

set -- \
        "-Dorg.gradle.appname=$APP_BASE_NAME" \
        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
        "$@"

# Stop when "xargs" is not available.
if ! command -v xargs >/dev/null 2>&1
then
    die "xargs is not available"
fi

# Use "xargs" to parse quoted args.
#

        int activeCrawlerNum = 0;
        try {
            while (startedCrawlerNum < crawlerList.size()) {
                // Force to stop crawl
                if (systemHelper.isForceStop()) {
                    for (final Crawler crawler : crawlerList) {
                        crawler.stop();
                    }
                    break;
                }

import org.codelibs.fess.util.JobProcess;

import jakarta.annotation.PreDestroy;

/**
 * Helper class for managing system processes in Fess.
 * This class provides functionality to start, stop, and manage external processes
 * such as crawler processes, with proper resource cleanup and lifecycle management.
 */
public class ProcessHelper {
    /** Logger instance for this class */