for len(p.workers) < n {
		input := make(chan ReplicationWorkerOperation, 10000)
		p.workers = append(p.workers, input)

		go p.AddWorker(input, &p.activeWorkers)
	}
	for len(p.workers) > n {
		worker := p.workers[len(p.workers)-1]
		p.workers = p.workers[:len(p.workers)-1]
		xioutil.SafeClose(worker)
	}
}

// ResizeWorkerPriority sets replication failed workers pool size

}

type replicationResyncer struct {
	// map of bucket to their resync status
	statusMap      map[string]BucketReplicationResyncStatus
	workerSize     int
	resyncCancelCh chan struct{}
	workerCh       chan struct{}
	sync.RWMutex
}

const (
	replicationDir      = ".replication"
	resyncFileName      = "resync.bin"
	resyncMetaFormat    = 1
	resyncMetaVersionV1 = 1

		workers = workers[:len(workers)-1]
		worker <- expiryOp(nil)
		es.stats.workers.Add(-1)
	}
	// Atomically replace workers.
	es.workers.Store(&workers)
}

// Worker handles 4 types of expiration tasks.
// 1. Expiry of objects, includes regular and transitioned objects
// 2. Expiry of noncurrent versions due to NewerNoncurrentVersions

        "gradle-base-services",
        "gradle-enterprise-logging",
        "gradle-enterprise-workers",
        "gradle-cli",
        "gradle-concurrent",
        "gradle-io",
        "gradle-wrapper-shared",
        "gradle-native",
        "gradle-dependency-management",
        "gradle-workers",
        "gradle-worker-main",
        "gradle-build-process-services",
        "gradle-problems-api",

					"ivy",
					"testing-native",
					"maven",
					"integ-test"
				]
			},
			{
				"parallelizationMethod":{
					"name":"TestDistribution"
				},
				"subprojects":[
					"workers",
					"model-core",
					"language-groovy",
					"build-init",
					"logging",
					"plugins-groovy",
					"kotlin-dsl",
					"plugins-java",
					"samples",
					"plugin-development",

    }

    // This test simulates a long running Zinc compiler setup by running code similar to ZincScalaCompilerFactory through the worker API.
    // if many workers wait for the same exclusive lock, a worker does not time out because several others get the lock before
    def "worker not timeout"() {
        given:
        def gradleUserHome = file("home").absoluteFile
        buildFile << """

    api(project(":language-jvm"))
    api(project(":problems-api"))
    api(project(":platform-base"))
    api(project(":toolchains-jvm"))
    api(project(":toolchains-jvm-shared"))
    api(project(":workers"))
    api(project(":worker-main"))
    api(project(":build-process-services"))

    api(libs.inject)
    api(libs.jsr305)

    implementation(projects.concurrent)
    implementation(projects.stdlibJavaExtensions)

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction
import org.gradle.process.ExecOperations
import org.gradle.workers.WorkAction
import org.gradle.workers.WorkParameters
import org.gradle.workers.WorkQueue
import org.gradle.workers.WorkerExecutor

import javax.inject.Inject

import static org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.exec

    api(project(":model-core"))
    api(project(":platform-base"))
    api(project(":platform-jvm"))
    api(project(":toolchains-jvm"))
    api(project(":toolchains-jvm-shared"))
    api(project(":workers"))
    api(project(":build-process-services"))

    api(libs.groovy)
    api(libs.inject)
    api(libs.jsr305)

    implementation(projects.time)
    implementation(project(":dependency-management"))

    api(project(":process-services"))
    api(project(":snapshots"))
    api(project(":test-suites-base"))
    api(project(":toolchains-jvm"))
    api(project(":toolchains-jvm-shared"))
    api(project(":worker-main"))
    api(project(":workers"))
    api(project(":build-process-services"))

    api(libs.asm)
    api(libs.fastutil)
    api(libs.groovy)
    api(libs.guava)
    api(libs.jsr305)
    api(libs.inject)