// idle will result in loss of work conservation (idle P while there is
	// runnable work). This could result in complete deadlock in the
	// unlikely event that we discover new work (from netpoll) right as we
	// are racing with _all_ other Ps going idle.
	//
	// We use sched.needspinning to synchronize with non-spinning Ms going
	// idle. If needspinning is set when they are about to drop their P,

     */
    int getNumberOfBuilds();

    /**
     * @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();

    /**

)

const (
	shutdownPollIntervalMax = 500 * time.Millisecond

	// DefaultShutdownTimeout - default shutdown timeout to gracefully shutdown server.
	DefaultShutdownTimeout = 5 * time.Second

	// DefaultIdleTimeout for idle inactive connections
	DefaultIdleTimeout = 30 * time.Second

	// DefaultReadHeaderTimeout for very slow inactive connections
	DefaultReadHeaderTimeout = 30 * time.Second

        }
        if (lastRegistryState == state && lastLogState == state) {
            return
        }
        // TODO remove debug log
        if (lastRegistryState == State.Stopped && lastLogState == State.Idle) {
            println("The daemon probably disappeared before it could've printed the stop message. Daemon log content:")
            println(logFile.text)
        }

        blockingServer.expect(':c:ping')

        run 'd:ping'
    }

    void 'tasks with should run after ordering rules are preferred when running over an idle worker thread'() {
        buildFile << """
            tasks.getByPath(':a:pingA').shouldRunAfter(':b:pingB')
            tasks.getByPath(':b:pingB').dependsOn(':b:pingA')
        """

        expect:

                                  format: int32
                                  type: integer
                                idleTimeout:
                                  description: The idle timeout for upstream connection
                                    pool connections.
                                  type: string
                                  x-kubernetes-validations:

        requireIsolatedTestKitDir = true
    }

    @Rule
    final ConcurrentTestUtil concurrent = new ConcurrentTestUtil(60000)

    def "daemon process dedicated to test execution uses short idle timeout"() {
        when:
        runner().build()

        then:
        testKitDaemons().daemon.context.idleTimeout == 120000
    }

        def exception = thrown(IllegalArgumentException)
        exception.message == "Changed path '${Paths.get(changedPaths[0])}' is not absolute"
    }

    @TargetGradleVersion(">=6.1")
    def "invalidates paths for single idle daemon"() {
        when:
        createIdleDaemon()

        withConnection { connection ->
            connection.notifyDaemonsAboutChangedPaths(toPaths(changedPaths))
        }

        then:

// package.
//
// If pingPeriod is non-zero, for each incoming connection a background
// goroutine will send periodic Ping frames to the server. Use this to keep
// idle connections through certain load balancers alive longer.
func NewResponseUpgraderWithPings(pingPeriod time.Duration) httpstream.ResponseUpgrader {
	return responseUpgrader{pingPeriod: pingPeriod}
}

	ProcNotExist                      // Proc does not exist.
	ProcRunning                       // Proc is running.
	ProcIdle                          // Proc is idle.
)

// Executing returns true if the state indicates that the proc is executing
// and bound to its thread.
func (s ProcState) Executing() bool {
	return s == ProcRunning
}