/**
 * Terminates the external running 'sub' process when the Gradle process is being cancelled.
 */
public class ExecHandleShutdownHookAction implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(ExecHandleShutdownHookAction.class);
    private final ExecHandle execHandle;

    public ExecHandleShutdownHookAction(ExecHandle execHandle) {
        if (execHandle == null) {

import org.codelibs.core.log.Logger;

/**
 * Utility class for Thread class
 *
 * @author shinsuke
 *
 */
public abstract class ThreadUtil {

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

    public static void sleep(final long millis) {
        if (millis < 1L) {
            return;
        }
        try {
            Thread.sleep(millis);

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.fess.util.ComponentUtil;

public class PurgeThumbnailJob {
    private static final Logger logger = LogManager.getLogger(PurgeThumbnailJob.class);

    private long expiry = 30 * 24 * 60 * 60 * 1000L;

    public String execute() {
        try {
            final long count = ComponentUtil.getThumbnailManager().purge(getExpiry());

 *
 * <p>It is instantiated and called from {@link SystemApplicationClassLoaderWorker}.<p>
 */
public class ActionExecutionWorker implements Action<WorkerProcessContext> {
    private static final Logger LOGGER = LoggerFactory.getLogger(ActionExecutionWorker.class);
    private final Action<? super WorkerProcessContext> action;

    public ActionExecutionWorker(Action<? super WorkerProcessContext> action) {
        this.action = action;
    }

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DefaultToolchainJavaCompiler implements JavaCompiler {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultToolchainJavaCompiler.class);

    private final JavaToolchain javaToolchain;
    private final JavaCompilerFactory compilerFactory;

            this.failure = failure
        }
    }

    abstract protected List<? extends ServerExpectation> getExpectations()

    abstract protected void stop()

    abstract protected Logger getLogger()

import org.codelibs.fess.dict.DictionaryFile;
import org.codelibs.fess.dict.DictionaryItem;

public class KuromojiCreator extends DictionaryCreator {
    private static final Logger logger = LogManager.getLogger(KuromojiCreator.class);

    public KuromojiCreator() {
        super("kuromoji.*\\.txt");
    }

    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {

import org.codelibs.fess.dict.DictionaryFile;
import org.codelibs.fess.dict.DictionaryItem;

public class CharMappingCreator extends DictionaryCreator {
    private static final Logger logger = LogManager.getLogger(CharMappingCreator.class);

    public CharMappingCreator() {
        super("mapping.*\\.txt");
    }

    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {

import org.codelibs.fess.dict.DictionaryFile;
import org.codelibs.fess.dict.DictionaryItem;

public class StemmerOverrideCreator extends DictionaryCreator {
    private static final Logger logger = LogManager.getLogger(StemmerOverrideCreator.class);

    public StemmerOverrideCreator() {
        super("stemmer_override.*\\.txt");
    }

    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {

/**
 * Install a handler for cancel request processed asynchronously while the daemon proceeds to build execution.
 */
public class HandleCancel implements DaemonCommandAction {
    private static final Logger LOGGER = Logging.getLogger(HandleCancel.class);

    @Override
    public void execute(final DaemonCommandExecution execution) {
        execution.getConnection().onCancel(new Runnable() {
            @Override
            public void run() {