import org.gradle.internal.serialize.StatefulSerializer;

/**
 * A builder that allows a {@link Connection} to be created once the underlying transport with the peer has been
 * established.
 */
public interface ConnectCompletion {
    /**
     * Creates the connection. Uses the specified serializer for all messages.
     *
     * @return The serializer to use.
     */
    <T> RemoteConnection<T> create(StatefulSerializer<T> serializer);

        Address address = Stub()
        ConnectCompletion connectCompletion = Mock()
        RemoteConnection<InterHubMessage> backingConnection = Mock()
        ManagedExecutor executor = Mock()

        when:
        def objectConnection = client.getConnection(address)

        then:
        1 * connector.connect(address) >> connectCompletion
        1 * executorFactory.create("${connectCompletion} workers") >> executor

        when:

class MessageHubBackedObjectConnectionTest extends ConcurrentSpec {
    def connectCompletion = Mock(ConnectCompletion)
    def connectionBuilder = new MessageHubBackedObjectConnection(executorFactory, connectCompletion)

    interface Worker {
        void doStuff(String value)
    }

    interface CompletableWorker extends Worker, StreamCompletion {
    }

            // thread while we are in the middle here.

            Action<ConnectCompletion> connectEvent = new Action<ConnectCompletion>() {
                @Override
                public void execute(ConnectCompletion completion) {
                    RemoteConnection<Message> remoteConnection;
                    try {

    }

    private class Receiver implements Runnable {
        private final ServerSocketChannel serverSocket;
        private final Action<ConnectCompletion> action;
        private final boolean allowRemote;

        public Receiver(ServerSocketChannel serverSocket, Action<ConnectCompletion> action, boolean allowRemote) {
            this.serverSocket = serverSocket;
            this.action = action;

        Action<ObjectConnection> connectAction = Mock()
        RemoteConnection<InterHubMessage> backingConnection = Mock()
        ManagedExecutor executor = Mock()
        ConnectCompletion completion = Mock()
        Action<ConnectCompletion> acceptAction
        def connection

        when:
        server.accept(connectAction)

        then:

    }

    private class ConnectEventAction implements Action<ConnectCompletion> {
        private final Action<ObjectConnection> action;

        public ConnectEventAction(Action<ObjectConnection> action) {
            this.action = action;
        }

        @Override
        public void execute(ConnectCompletion completion) {

import org.gradle.internal.remote.internal.RemoteConnection;
import org.gradle.internal.serialize.StatefulSerializer;
import org.gradle.internal.remote.internal.ConnectCompletion;

import java.nio.channels.SocketChannel;

class SocketConnectCompletion implements ConnectCompletion {
    private final SocketChannel socket;

    public SocketConnectCompletion(SocketChannel socket) {
        this.socket = socket;
    }

    @Override

 * limitations under the License.
 */
package org.gradle.internal.remote.internal.inet

import org.gradle.api.Action
import org.gradle.internal.id.UUIDGenerator
import org.gradle.internal.remote.internal.ConnectCompletion
import org.gradle.internal.remote.internal.ConnectException
import org.gradle.internal.remote.internal.MessageIOException
import org.gradle.internal.serialize.BaseSerializerFactory

import org.gradle.internal.dispatch.StreamCompletion;
import org.gradle.internal.exceptions.DefaultMultiCauseException;
import org.gradle.internal.remote.ObjectConnection;
import org.gradle.internal.remote.internal.ConnectCompletion;
import org.gradle.internal.remote.internal.RemoteConnection;
import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage;
import org.gradle.internal.serialize.SerializerRegistry;