apiVersion: release-notes/v2
kind: feature
area: traffic-management
issue: []
releaseNotes:
  - |

Jacek Ewertowski <******@****.***> 1702999098 +0100

        then:
        all.size() == 2
        idle.size() == 1
        notIdle.size() == 1

        when:
        markState(address(20), Busy)

        then:
        all.size() == 2
        idle.empty
        notIdle.size() == 2

        when:
        markState(address(10), Idle)
        markState(address(20), Idle)

        then:
        all.size() == 2
        idle.size() == 2
        notIdle.empty

		Enable:   true,
		Idle:     20 * time.Second,
		Interval: -1,
		Count:    10,
	},
	{
		Enable:   true,
		Idle:     20 * time.Second,
		Interval: 10 * time.Second,
		Count:    -1,
	},
	{
		Enable:   true,
		Idle:     -1,
		Interval: -1,
		Count:    10,
	},
	{
		Enable:   true,
		Idle:     -1,
		Interval: 10 * time.Second,
		Count:    -1,
	},
	{
		Enable:   true,
		Idle:     20 * time.Second,

        completeBuild()

        then:
        idle()

        and:
        stopped()
    }

    //Java 9 and above needs --add-opens to make environment variable mutation work
    @Requires(UnitTestPreconditions.Jdk8OrEarlier)
    def "existing foreground idle daemons are used"() {
        when:
        startForegroundDaemon()

        then:
        idle()

        when:
        startBuild()

		Idle:     5 * time.Second,
		Interval: -1,
		Count:    10,
	},
	{
		Enable:   true,
		Idle:     5 * time.Second,
		Interval: 3 * time.Second,
		Count:    -1,
	},
	{
		Enable:   true,
		Idle:     -1,
		Interval: -1,
		Count:    10,
	},
	{
		Enable:   true,
		Idle:     -1,
		Interval: 3 * time.Second,
		Count:    -1,
	},
	{
		Enable:   true,
		Idle:     5 * time.Second,

 */
package org.gradle.launcher.daemon.testing

/**
 * Represents the number of given busy and idle daemons in a registry at a particular time.
 */
class DaemonsState {
    final int busy
    final int idle

    DaemonsState(int busy, int idle) {
        this.busy = Math.max(busy, 0)
        this.idle = Math.max(idle, 0)
    }

    static getWildcardState() {
        new DaemonsState()
    }

		// Now we will use the default of KeepAliveInterval on Windows if user doesn't
		// provide one.
		interval = defaultKeepAliveInterval
	case idle < 0 && interval < 0:
		// Nothing to do, just bail out.
		return nil
	case idle >= 0 && interval >= 0:
		// Go ahead.
	}

	if idle == 0 {
		idle = defaultTCPKeepAliveIdle
	}
	if interval == 0 {
		interval = defaultTCPKeepAliveInterval
	}

        state(busy, numDaemons - busy)
    }

    void idle() {
        idle(numDaemons)
    }

    void idle(int idle) {
        state(numDaemons - idle, idle)
    }

    void stopped() {
        numDaemons = 0
        state(0, 0)
    }

    void state(int busy, int idle) {
        state(new DaemonsState(busy, idle))
    }

    void state(DaemonsState checkpointState) {

		return
	}
	cfg = KeepAliveConfig{
		Enable:   tcpKeepAlive != 0,
		Idle:     time.Duration(tcpKeepAliveIdle) * time.Second,
		Interval: time.Duration(tcpKeepAliveInterval) * time.Second,
		Count:    tcpKeepAliveCount,
	}
	return
}

func verifyKeepAliveSettings(t *testing.T, fd fdType, oldCfg, cfg KeepAliveConfig) {
	if cfg.Idle == 0 {
		cfg.Idle = defaultTCPKeepAliveIdle
	}
	if cfg.Interval == 0 {