*
     * @since 8.7
     */
    String getOriginBuildInvocationId();

    /**
     * The build cache key of the work in the origin build invocation.
     *
     * @since 8.7
     */
    byte[] getOriginBuildCacheKeyBytes();

    /**
     * The execution time of the work in the build that produced the outputs being reused.
     *
     * @since 8.7
     */

    def "can use multiple action implementations with different classpath roots and loaded from same ClassLoader"() {
        settingsFile.text = 'rootProject.name = "not broken"'

        // Ensure daemon is reused
        toolingApi.requireIsolatedDaemons()

        // Copy each of the action classes into its own classes directory and load into a single ClassLoader

          },
          "route": {
           "cluster": "outbound|8000||httpbin.default.svc.cluster.local",
           "timeout": "0s",
           "retry_policy": {
            "retry_on": "connect-failure,refused-stream,unavailable,cancelled,retriable-status-codes",
            "num_retries": 2,
            "retry_host_predicate": [
             {
              "name": "envoy.retry_host_predicates.previous_hosts",

            }
        }
        settingsFile << withHttpBuildCacheServer()

        // We see connection refused because the first partial request is retried,
        // then the subsequent is flat refused because we stopped the server.
        String errorPattern = /(Connect to 127\.0\.0\.1:\d+ \[\/127\.0\.0\.1\] failed: Connection refused|127\.0\.0\.1:\d+ failed to respond|Connection reset)/

        when:

        DefaultClassPath.of(paths.collect { file(it) } as Iterable<File>)
    }

    ClassLoader classLoader(ClassPath classPath) {
        new URLClassLoader(classPath.asURLArray)
    }

    def "class loaders are reused when parent, class path and implementation hash are the same"() {
        expect:
        def root = classLoader(classPath("root"))
        cache.get(id1, classPath("c1"), root, null) == cache.get(id1, classPath("c1"), root, null)

@IntegrationTestTimeout(180)
class WorkerDaemonLifecycleTest extends AbstractDaemonWorkerExecutorIntegrationSpec {
    String logSnapshot = ""

    def "worker daemons are not reused across builds"() {
        fixture.withWorkActionClassInBuildScript()
        buildFile << """
            import org.gradle.workers.internal.WorkerDaemonFactory

            task runInWorker1(type: WorkerTask) {

        when:
        configurationCacheRun "help", "--offline"
        then:
        configurationCache.assertStateStored()

        // Now repeat invocations in different order to make sure both entries can be reused
        when:
        configurationCacheRun "help"
        then:
        configurationCache.assertStateLoaded()

        when:
        configurationCacheRun "help", "--offline"
        then:

        result.assertHasPostBuildOutput("Configuration cache entry stored.")

        when:
        configurationCacheRun("ok")

        then:
        result.assertHasPostBuildOutput("Configuration cache entry reused.")

        when:
        configurationCacheFails("broken")

        then:
        outputContains("Configuration cache entry discarded with 2 problems.")
        problems.assertFailureHasProblems(failure) {

     */
    public ImmutableList<String> getExecutionReasons() {
        return executionReasons;
    }

    /**
     * If a previously produced output was reused in some way, the reused output's origin metadata is returned.
     */
    public Optional<OriginMetadata> getReusedOutputOriginMetadata() {
        return Optional.ofNullable(reusedOutputOriginMetadata);
    }

 */

package org.gradle.internal.execution;

import org.gradle.internal.execution.workspace.ImmutableWorkspaceProvider;

/**
 * A unit of work that will only be executed atomically and its outputs be reused indefinitely from an immutable workspace.
 */
public interface ImmutableUnitOfWork extends UnitOfWork {
    /**
     * Returns the {@link ImmutableWorkspaceProvider} to allocate a workspace to execution this work in.
     */