* generally some configuration thread. Only the stop methods are thread-safe. The other methods will be made thread-safe (or moved somewhere else) later.
 */
public interface ObjectConnection extends AsyncStoppable, ObjectConnectionBuilder {
    /**
     * Completes the connection. No further configuration can be done.
     */
    void connect();

    /**

class ForkingTestClassProcessorTest extends Specification {
    WorkerThreadRegistry workerLeaseRegistry = Mock(WorkerThreadRegistry)
    RemoteTestClassProcessor remoteProcessor = Mock(RemoteTestClassProcessor)
    ObjectConnection connection = Mock(ObjectConnection) {
        addOutgoing(RemoteTestClassProcessor.class) >> remoteProcessor
    }
    WorkerProcess workerProcess = Mock(WorkerProcess) {
        getConnection() >> connection
    }

    }

    @Override
    public ConnectionAcceptor accept(Action<ObjectConnection> action) {
        return connector.accept(new ConnectEventAction(action), false);
    }

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

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

import org.gradle.api.Describable;
import org.gradle.internal.remote.ObjectConnection;
import org.gradle.process.ExecResult;
import org.gradle.process.internal.health.memory.JvmMemoryStatus;

import java.util.Optional;

/**
 * A child JVM that performs some worker action. You can send and receive messages to/from the worker action
 * using a supplied {@link ObjectConnection}.
 */
public interface WorkerProcess extends Describable {

 * limitations under the License.
 */

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

import org.gradle.api.Action;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.remote.ObjectConnection;
import org.gradle.process.internal.worker.WorkerProcessContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>The final stage of worker start-up. Takes care of executing the worker action.</p>

        try {
            this.acceptor = acceptor;
        } finally {
            lock.unlock();
        }
    }

    public void onConnect(ObjectConnection connection) {
        onConnect(connection, null);
    }

    public void onConnect(ObjectConnection connection, Runnable connectionHandler) {
        AsyncStoppable stoppable;
        lock.lock();
        try {

     */
    String getDisplayName();

    /**
     * Returns the connection which can be used to send/receive messages to/from the server process. Call {@link ObjectConnection#connect()} to complete the connection.
     */
    ObjectConnection getServerConnection();

    ClassLoader getApplicationClassLoader();

    ServiceRegistry getServiceRegistry();

import org.gradle.internal.remote.Address;
import org.gradle.internal.remote.internal.OutgoingConnector;
import org.gradle.internal.remote.MessagingClient;
import org.gradle.internal.remote.ObjectConnection;

public class MessageHubBackedClient implements MessagingClient {
    private final OutgoingConnector connector;
    private final ExecutorFactory executorFactory;

import org.gradle.internal.exceptions.DefaultMultiCauseException;
import org.gradle.internal.nativeintegration.services.NativeServices.NativeServicesMode;
import org.gradle.internal.remote.ObjectConnection;
import org.gradle.internal.work.WorkerLeaseRegistry;
import org.gradle.internal.work.WorkerThreadRegistry;
import org.gradle.process.JavaForkOptions;
import org.gradle.process.internal.ExecException;

        ManagedExecutor executor = Mock()

        when:
        def objectConnection = client.getConnection(address)

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

        when:
        objectConnection.connect()

        then:
        1 * connectCompletion.create(_) >> backingConnection