import java.util.ArrayList;
import java.util.List;

/**
 * Provides information on how two processes on this machine can communicate via IP addresses
 */
@ServiceScope(Scope.Global.class)
public class InetAddressFactory {
    private final Logger logger = LoggerFactory.getLogger(getClass());
    private final Object lock = new Object();
    private List<InetAddress> communicationAddresses;
    private InetAddress localBindingAddress;

        return new DefaultFileLockContentionHandler(
            executorFactory,
            new InetAddressProvider() {
                @Override
                public InetAddress getWildcardBindingAddress() {
                    return inetAddressFactory.getWildcardBindingAddress();
                }

                @Override

    @Provides
    protected InetAddressFactory createInetAddressFactory() {
        return new InetAddressFactory();
    }

    @Provides
    protected OutgoingConnector createOutgoingConnector() {
        return new TcpOutgoingConnector();
    }

    @Provides
    protected IncomingConnector createIncomingConnector(ExecutorFactory executorFactory, InetAddressFactory inetAddressFactory) {
        return new TcpIncomingConnector(

    private ConnectionAcceptor acceptor;

    public DaemonTcpServerConnector(ExecutorFactory executorFactory, InetAddressFactory inetAddressFactory, Serializer<Message> serializer) {
        this.serializer = serializer;
        this.incomingConnector = new TcpIncomingConnector(
                executorFactory,
                inetAddressFactory,
                new UUIDGenerator()
        );
    }

    @Override

package org.gradle.cache.internal.locklistener

import org.gradle.internal.remote.internal.inet.InetAddressFactory
import org.gradle.util.ConcurrentSpecification

import static org.gradle.test.fixtures.ConcurrentTestUtil.poll

class FileLockCommunicatorTest extends ConcurrentSpecification {

    def addressFactory = new InetAddressFactory()
    def communicator = new FileLockCommunicator(new InetAddressProvider() {
        @Override

        ExecutorFactory executorFactory,
        InetAddressFactory inetAddressFactory,
        DaemonRegistry daemonRegistry,
        DaemonContext daemonContext,
        ListenerManager listenerManager
    ) {
        return new Daemon(
            new DaemonTcpServerConnector(
                executorFactory,
                inetAddressFactory,
                DaemonMessageSerializer.create(buildActionSerializer)

 * limitations under the License.
 */

package org.gradle.internal.remote.internal.inet

import spock.lang.Specification

class InetAddressFactoryTest extends Specification {

    def factory = new InetAddressFactory()
    InetAddresses addresses = Mock()

    def setup() {
        factory.inetAddresses = addresses
    }

    def "Loopback addresses are preferred"() {
        when:

    private final ExecutorFactory executorFactory;
    private final InetAddressFactory addressFactory;
    private final IdGenerator<UUID> idGenerator;

    public TcpIncomingConnector(ExecutorFactory executorFactory, InetAddressFactory addressFactory, IdGenerator<UUID> idGenerator) {
        this.executorFactory = executorFactory;
        this.addressFactory = addressFactory;

import org.gradle.cache.internal.locklistener.InetAddressProvider
import org.gradle.internal.concurrent.CompositeStoppable
import org.gradle.internal.remote.internal.inet.InetAddressFactory
import org.gradle.test.fixtures.concurrent.ConcurrentSpec
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule

import java.util.function.Consumer

 * limitations under the License.
 */

package org.gradle.launcher.daemon


import org.gradle.integtests.fixtures.daemon.DaemonIntegrationSpec
import org.gradle.internal.remote.internal.inet.InetAddressFactory
import org.gradle.launcher.daemon.logging.DaemonMessages
import org.gradle.test.fixtures.Flaky
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions