import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * A consumer for build events provided by the build requester. This can be used to forward events to the build requester.
 */
@ServiceScope(Scope.BuildSession.class)
public interface BuildEventConsumer extends Dispatch<Object> {

 * limitations under the License.
 */

package org.gradle.internal.dispatch;

import org.gradle.internal.UncheckedException;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectionDispatch implements Dispatch<MethodInvocation> {
    private final Object target;

    public ReflectionDispatch(Object target) {

        Throwable ex
        final TestListenerInterface dispatch

        public RemoteExceptionListener(TestListenerInterface dispatch) {
            this.dispatch = dispatch
        }

        void send(String message, int count) {
            try {
                dispatch.send(message, count)
            } catch (Throwable e) {
                ex = e
            }

        1 * buildFinishedAction.execute(_) >> result2
        1 * buildEventConsumer.dispatch({
            it instanceof PhasedBuildActionResult &&
                it.phase == PhasedActionResult.Phase.PROJECTS_LOADED &&
                it.result == serializedResult1
        })
        1 * buildEventConsumer.dispatch({
            it instanceof PhasedBuildActionResult &&

        throwWhen(new IOException("Could not dispatch a message to the daemon.", new IOException("An existing connection was forcibly closed by the remote host")), iteration == 1)

        then:
        def ioe = thrown(IOException)
        ioe.message == "Could not dispatch a message to the daemon."
    }

    private static void throwWhen(Throwable throwable, boolean condition) {

                }
                dispatch(connection, new InvalidateVirtualFileSystemAfterChange(changedPaths, idGenerator.generateId(), connection.getDaemon().getToken()));
            }
        }
    }

    private static void dispatch(Connection<Message> connection, Command command) {
        Throwable failure = null;
        try {
            connection.dispatch(command);

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.internal.daemon.client.clientinput

import org.gradle.internal.dispatch.Dispatch
import org.gradle.internal.logging.console.DefaultUserInputReceiver
import org.gradle.internal.logging.events.OutputEventListener
import org.gradle.internal.logging.events.PromptOutputEvent

        "bytecode upgrade" | "Groovy callsite"          | { it.testBytecodeUpgrade() }  | false          | null

        "instrumentation " | "Groovy dynamic dispatch " | { testInstrumentation() }     | true           | "testInstrumentation()"
        "bytecode upgrade" | "Groovy dynamic dispatch"  | { testBytecodeUpgrade() }     | true           | null
    }

    def 'intercepts a basic instance call with #method from #caller with `all` filter'() {

    public boolean dispatch(Connection<Message> connection, Command stopCommand) {
        Throwable failure = null;
        try {
            connection.dispatch(stopCommand);
            Result result = (Result) connection.receive();
            if (result instanceof Failure) {
                failure = ((Failure) result).getValue();
            }
            connection.dispatch(new Finished());

So we have a dedicated thread for every socket that just reads frames and dispatches them.

The reader thread must never run application-layer code. Otherwise one slow stream can hold up the entire connection.