* limitations under the License.
 */

package org.gradle.process.internal.worker.child;

import org.gradle.internal.logging.events.LogEvent;
import org.gradle.internal.logging.events.StyledTextOutputEvent;

/**
 * Protocol for sending logging information back from a worker process to the daemon.
 */
public interface WorkerLoggingProtocol {
    /**

 * limitations under the License.
 */

package org.gradle.process.internal.worker.problem;

import org.gradle.api.NonNullApi;
import org.gradle.api.problems.internal.Problem;
import org.gradle.api.problems.internal.ProblemEmitter;
import org.gradle.internal.operations.OperationIdentifier;

import javax.annotation.Nullable;

/**
 * Worker-side implementation of {@link ProblemEmitter}.
 * <p>

                return useCurrentProcess
            }
        }
    }

    def "check that --max-workers overrides org.gradle.workers.max"() {
        when:
        def action = convert('--max-workers=5')

        then:
        unwrapAction(action).startParameter.maxWorkerCount == 5
    }

    def "by default daemon is used"() {
        when:

plugins {
    id("gradlebuild.distribution.api-java")
}

gradlebuildJava.usedInWorkers()

description = """Generalized test infrastructure to support executing tests in test workers."""

dependencies {
    api(projects.baseServices)
    api(projects.concurrent)
    api(projects.stdlibJavaExtensions)
    api(projects.messaging)
    api(projects.serialization)
    api(projects.time)
    api(projects.workerMain)

    api(libs.jsr305)

    id("gradlebuild.publish-public-libraries")
}

description = "Tools for creating secure hashes for files and other content"

gradlebuildJava.usedInWorkers() // org.gradle.internal.nativeintegration.filesystem.Stat is used in workers

dependencies {
    api(projects.stdlibJavaExtensions)

    implementation(libs.guava)
    api(libs.jsr305)

}

// ExpirationWait returns the duration for which a batch expiration worker
// would wait before working on next object.
func (opts Config) ExpirationWait() time.Duration {
	configMu.RLock()
	defer configMu.RUnlock()

	return opts.ExpirationWorkersWait
}

// ReplicationWait returns the duration for which a batch replication worker
// would wait before working on next object.

    runtimeOnly(project(":composite-builds"))
    runtimeOnly(project(":resources-http"))
    // TODO - move the isolatable serializer to model-core to live with the isolatable infrastructure
    runtimeOnly(project(":workers"))

    runtimeOnly(libs.kotlinReflect)

    testImplementation(projects.io)
    testImplementation(testFixtures(project(":core")))
    testImplementation(libs.mockitoKotlin2)

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.process.internal.worker.child;

import org.gradle.internal.logging.events.LogEvent;
import org.gradle.internal.logging.events.OutputEvent;
import org.gradle.internal.logging.events.OutputEventListener;

	// Worker processes may or may not receive a signal when the user presses ^C
	// On POSIX operating systems, a signal sent to a process group is delivered
	// to all processes in that group. This is not the case on Windows.
	// If the worker is interrupted, return quickly and without error.
	// If only the coordinator process is interrupted, it tells each worker
	// process to stop by closing its "fuzz_in" pipe.

    implementation(libs.slf4jApi)

    compileOnly("antlr:antlr:2.7.7") {
        because("this dependency is downloaded by the antlr plugin")
    }

    runtimeOnly(project(":language-jvm"))
    runtimeOnly(project(":workers"))

    testImplementation(project(":base-services-groovy"))
    testImplementation(testFixtures(project(":core")))
    testImplementation(project(":file-collections"))