import org.gradle.process.ExecOperations
import org.slf4j.LoggerFactory
import java.util.concurrent.ConcurrentHashMap
import javax.inject.Inject


private
val logger = LoggerFactory.getLogger("daemonTracker")


abstract class DaemonTracker : BuildService<DaemonTracker.Params>, AutoCloseable {
    interface Params : BuildServiceParameters {
        val rootProjectDir: DirectoryProperty
    }

        toolExec.setStandardOutput(stdOutput.getOutputStream());

        try {
            toolExec.execute();
            invocation.getLogger().operationSuccess(description.getDisplayName(), combineOutput(stdOutput, errOutput));
        } catch (ExecException e) {
            invocation.getLogger().operationFailed(description.getDisplayName(), combineOutput(stdOutput, errOutput));

    public void setUrl(String url) {
        this.url = url;
    }

    @Input
    public String getUrl() {
        return url;
    }

    @TaskAction
    public void verify() {
        getLogger().quiet("Verifying URL '{}'", url);

        // verify URL by making a HTTP call
    }
}

     */
    open val initscript: ScriptHandler
        get() = host.scriptHandler

    private
    class InitScriptHost(val host: KotlinScriptHost<Gradle>) : Host {
        override fun getLogger(): Logger = Logging.getLogger(Gradle::class.java)
        override fun getLogging(): LoggingManager = host.target.serviceOf()
        override fun getFileOperations(): FileOperations = host.fileOperations

  public void apply(Project project) {
    Task goodbye = project.getTasks().create("goodbye");
    goodbye.doLast(new Action<Task>() {
      @Override
      public void execute(Task task) {
        task.getLogger().lifecycle("Goodbye!");
      }
    });
  }

            }
        } catch (HttpCallException e) {
            throw new GradleException(String.format("Failed to resolve url '%s'", url, e));
        }

        getLogger().quiet(String.format("Successfully resolved URL '%s'", url));
    }

    void setHttpCaller(HttpCaller httpCaller) {
        this.httpCaller = httpCaller;
    }

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

public class SingleFirePendingChangesListener implements PendingChangesListener {
    private static final Logger LOGGER = LoggerFactory.getLogger(SingleFirePendingChangesListener.class);

    private final PendingChangesListener delegate;
    private boolean seenChanges;

    public SingleFirePendingChangesListener(PendingChangesListener delegate) {

        if (problems.isEmpty()) {
            getLogger().info("Plugin validation finished without warnings.");
        } else {
            if (getFailOnWarning().get() || problems.stream().anyMatch(problem -> problem.getDefinition().getSeverity() == ERROR)) {
                if (getIgnoreFailures().get()) {
                    getLogger().warn("Plugin validation finished with errors. {} {}",

object LoggerCodec : Codec<Logger> {

    override suspend fun WriteContext.encode(value: Logger) {
        writeString(value.name)
    }

    override suspend fun ReadContext.decode(): Logger? =
        LoggerFactory.getLogger(readString())

if (gradle.parent == null) {
    useLogger(new CustomLogger())
}

class CustomLogger extends BuildAdapter implements BuildListener, ProjectEvaluationListener, TaskExecutionListener, TaskActionListener {
    def logger = Logging.getLogger('init-script')

    public void buildFinished(BuildResult result) {
        logger.info("LOGGER: build finished")
        println 'init callback quiet out'
    }

    public void beforeEvaluate(Project project) {