import org.gradle.internal.nativeintegration.services.NativeServices.NativeServicesMode;

import java.io.File;
import java.util.List;

public interface DaemonServerConfiguration {

    File getBaseDir();

    int getIdleTimeout();

    int getPeriodicCheckIntervalMs();

    String getUid();

    List<String> getJvmOptions();

    DaemonParameters.Priority getPriority();

    boolean isSingleUse();

            canonicalize(Jvm.current().getJavaHome()),
            JavaLanguageVersion.current(),
            configuration.getBaseDir(),
            processEnvironment.maybeGetPid(),
            configuration.getIdleTimeout(),
            configuration.getJvmOptions(),
            agentStatus.isAgentInstrumentationEnabled(),
            configuration.getNativeServicesMode(),
            configuration.getPriority()
        );
    }

     */
    File getDaemonRegistryDir();

    /**
     * The process id of the daemon.
     */
    Long getPid();

    /**
     * The daemon's idle timeout in milliseconds.
     */
    Integer getIdleTimeout();

    /**
     * Returns the JVM options that the daemon was started with.
     *
     * @return the JVM options that the daemon was started with
     */
    Collection<String> getDaemonOpts();

    /**

    /**
     * @return The time (milliseconds) since epoch at which the daemon was started
     */
    long getStartedAt();

    /**
     * @return The idle timeout (milliseconds) of the daemon
     */
    long getIdleTimeout();

    /**
     * @return The number of running daemons
     */
    int getNumberOfRunningDaemons();

    /**
     * @return true if daemon is single use daemon, false otherwise
     */

            new NotMostRecentlyUsedDaemonExpirationStrategy(daemon)
        )));

        // Expire after normal idle timeout
        strategies.add(new DaemonIdleTimeoutExpirationStrategy(daemon, params.getIdleTimeout(), TimeUnit.MILLISECONDS));

        // Expire recently unused Daemons when memory pressure is high
        addLowMemoryDaemonExpirationStrategyWhenSupported(daemon, strategies, listenerManager);

        this.nativeServicesMode = nativeServicesMode;
    }

    @Override
    public File getBaseDir() {
        return daemonBaseDir;
    }

    @Override
    public int getIdleTimeout() {
        return idleTimeoutMs;
    }

    @Override
    public int getPeriodicCheckIntervalMs() {
        return periodicCheckIntervalMs;
    }

    @Override
    public String getUid() {

    public int getNumberOfBuilds() {
        return stats.getBuildCount();
    }

    @Override
    public long getStartedAt() {
        return stats.getStartTime();
    }

    @Override
    public long getIdleTimeout() {
        return idleTimeout;
    }

    @Override
    public int getNumberOfRunningDaemons() {
        return daemonRegistry.getAll().size();
    }

    @Override
    public boolean isSingleUse() {

        if (daemonParameters.isForeground()) {
            ForegroundDaemonConfiguration conf = new ForegroundDaemonConfiguration(
                UUID.randomUUID().toString(), daemonParameters.getBaseDir(), daemonParameters.getIdleTimeout(), daemonParameters.getPeriodicCheckInterval(), fileCollectionFactory,
                daemonParameters.shouldApplyInstrumentationAgent(), daemonParameters.getNativeServicesMode());

	includeMx bool,
) []*listener.Filter {
	idleTimeout := destinationRule.GetTrafficPolicy().GetConnectionPool().GetTcp().GetIdleTimeout()
	if idleTimeout == nil {
		idleTimeout = parseDuration(lb.node.Metadata.IdleTimeout)
	}
	tcpProxy := &tcp.TcpProxy{
		StatPrefix:                      statPrefix,

    public File getDaemonRegistryDir() {
        return daemonRegistryDir;
    }

    @Override
    public Long getPid() {
        return pid;
    }

    @Override
    public Integer getIdleTimeout() {
        return idleTimeout;
    }

    @Override
    public Collection<String> getDaemonOpts() {
        return daemonOpts;
    }

    @Override