this.participants = participants;
        }

        @Override
        public void withParticipatingModules(Action<ModuleIdentifier> action) {
            for (ModuleIdentifier participant : participants) {
                action.execute(participant);
            }
        }

        @Override
        public boolean conflictExists() {
            return true;
        }
    }

        private Object executeAction(Object action, DefaultBuildController internalBuildController) {
            if (action instanceof InternalBuildActionVersion2<?>) {
                return ((InternalBuildActionVersion2) action).execute(internalBuildController);
            } else {
                return ((org.gradle.tooling.internal.protocol.InternalBuildAction) action).execute(internalBuildController);
            }
        }

        getStartParameter() >> startParameter
        getRootProject() >> project
    }

    def "executes buildSrc configuration action after projects are loaded"() {
        def action = Mock(Action)
        def listener = new BuildSrcBuildListenerFactory(action, new DefaultScriptClassPathResolver(
            TestUtil.objectInstantiator(),
            Stub(AgentStatus),
            Stub(Gradle)
        )).create()

) {
    fun <G : Any> deserialize(action: SerializedIsolatedActionGraph<G>): G =
        readerContextFor(action).useToRun {
            runReadOperation {
                withIsolate(owner) {
                    readNonNull()
                }
            }
        }

    private
    fun readerContextFor(
        action: SerializedIsolatedActionGraph<*>
    ) = DefaultReadContext(

        override fun <T : Any> useForStateLoad(stateType: StateType, action: (ConfigurationCacheStateFile) -> T): T {
            return useForStateLoad { layout -> action(layout.fileFor(stateType)) }
        }

        override fun <T : Any> useForStateLoad(action: (Layout) -> T): T {
            return withExclusiveAccessToCache(baseDir) { cacheDir ->
                action(ReadableLayout(cacheDir))
            }
        }

) : BuildTreeModelCreator {
    override fun <T : Any> beforeTasks(action: BuildTreeModelAction<out T>) {
        cache.maybePrepareModel {
            delegate.beforeTasks(action)
        }
    }

    override fun <T : Any?> fromBuildModel(action: BuildTreeModelAction<out T>): T? {
        return cache.loadOrCreateModel {
            val model = delegate.fromBuildModel(action)

package org.gradle.internal.cc.impl.inputs.undeclared

import org.gradle.api.Action
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.test.fixtures.file.TestFile

trait JavaPluginImplementation {
    void javaPlugin(TestFile sourceFile, BuildInputRead read) {
        sourceFile << """
            import ${Action.name};
            import ${Project.name};
            import ${Plugin.name};

        this.uri = uri;
    }

    @Override
    public CustomModel execute(BuildController controller) {
        System.out.println("ACTION STARTED");
        GradleProject gradleProject = controller.getModel(GradleProject.class);
        controller.send(gradleProject);

        System.out.println("ACTION WAITING");
        try {
            uri.toURL().openConnection().getContentLength();
        } catch (IOException e) {

        String action = event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploading" : "Downloading";
        String direction = event.getRequestType() == TransferEvent.RequestType.PUT ? "to" : "from";

        TransferResource resource = event.getResource();
        MessageBuilder message = messageBuilderFactory.builder();
        message.style(STYLE).append(action).append(' ').append(direction).append(' ');

    override suspend fun WriteContext.encode(value: ActionNode) {
        withCodec(userTypesCodec) {
            write(value.action)
        }
    }

    override suspend fun ReadContext.decode(): ActionNode {
        val action = withCodec(userTypesCodec) { readNonNull<WorkNodeAction>() }
        return ActionNode(action)
    }