Ticket #4362: getaddrinfo-4362-3-1.patch

twisted/internet/base.py

@@ -17 +17 @@
 
 import traceback
 
+from twisted.python.util import FancyEqMixin
 from twisted.python.compat import set
 from twisted.internet.interfaces import IReactorCore, IReactorTime, IReactorThreads
 from twisted.internet.interfaces import IResolverSimple, IReactorPluggableResolver
 from twisted.internet.interfaces import IConnector, IDelayedCall
+from twisted.internet.interfaces import INameResolver
 from twisted.internet import fdesc, main, error, abstract, defer, threads
 from twisted.python import log, failure, _reflectpy3 as reflect
 from twisted.python.runtime import seconds as runtimeSeconds, platform
@@ -209 +211 @@
         return "".join(L)
 
 
+@implementer(INameResolver)
+class _ResolverComplexifier(object):
+    def __init__(self, resolver):
+        self._resolver = resolver
+
+
+    def getAddressInformation(self, name, service, *args):
+        d = self._resolver.getHostByName(name)
+        def cbResolved(address):
+            family = socket.getaddrinfo(address, 0)[0][0]
+            return [
+                AddressInformation(
+                    family,
+                    socket.SOCK_STREAM,
+                    socket.IPPROTO_TCP,
+                    "",
+                    (address, service))]
+        d.addCallback(cbResolved)
+        return d
+
+
 
 @implementer(IResolverSimple)
 class ThreadedResolver(object):
@@ -278 +301 @@
 
 
 
+class AddressInformation(object, FancyEqMixin):
+    compareAttributes = ('family', 'type', 'protocol', 'canonicalName', 'address')
+
+    def __init__(self, family, type, protocol, canonicalName, address):
+        self.family = family
+        self.type = type
+        self.protocol = protocol
+        self.canonicalName = canonicalName
+        self.address = address
+
+
+
 @implementer(IResolverSimple)
 class BlockingResolver:
 
@@ -507 +542 @@
             reflect.qual(self.__class__) + " did not implement installWaker")
 
     def installResolver(self, resolver):
-        assert IResolverSimple.providedBy(resolver)
+        resolver = INameResolver(resolver)
         oldResolver = self.resolver
         self.resolver = resolver
         return oldResolver
@@ -567 +602 @@
             return defer.succeed('0.0.0.0')
         if abstract.isIPAddress(name):
             return defer.succeed(name)
-        return self.resolver.getHostByName(name, timeout)
+        d = self.resolver.getAddressInformation(name, 0)
+        def cbGotInfo(addresses):
+            for info in addresses:
+                if info.family == socket.AF_INET:
+                    return info.address[0]
+            # XXX Test me
+        d.addCallback(cbGotInfo)
+        return d
+
 
     # Installation.
 

twisted/internet/interfaces.py

@@ -54 +54 @@
         """
 
 
+
+class INameResolver(Interface):
+    """
+    XXX Write me.
+
+    RFC 3484.
+    """
+    def getAddressInformation(name, service, family=None, socktype=None,
+                              proto=None, flags=None):
+        """
+        Get the address information associated with the given name.
+
+        @param name: A hostname to resolve.
+        @type name: C{str}
+
+        @param service: A port number or the name of the service for which to find address
+            information.  For example, C{22} or C{"ssh"}.
+        @type service: C{int} or C{str}
+
+        @param family: If specified, limit results to addresses from this family.  Must be one
+            of the address family constants from the socket module.  For example,
+            L{socket.AF_INET}.
+
+        @param socktype: If specified, limit results to addresses for this socket type.  Must be
+            one of the socket type constants from the socket module.  For example,
+            L{socket.SOCK_STREAM}.
+
+        @param proto: If specified, limit results to addresses for this socket protocol.  Must
+            be one of the protocol constants from the socket module.  For example,
+            L{socket.IPPROTO_TCP}.
+
+        @param flags: A bitvector specifying zero or more of the following::
+            - Yea right.  Go read the `getaddrinfo(3)` man page.
+
+        @raise ValueError: If one of the specified flags is not supported by the
+            implementation.  All flags are optional.
+
+        @return: A L{Deferred} which will fire when the resolution completes.  If resolution is
+            successful, the result will be a list of objects with the following attributes:
+
+            - C{family}: the family of this address
+            - C{type}: the type of this address
+            - C{protocol}: the protocol of this address
+            - C{canonicalName}: the canonical name associated with this address, or an empty
+                                string.
+            - C{address}: The actual address itself, including a port number.  This is suitable
+                          to be passed directly to L{socket.socket.connect}.
+        """
+
+
 class IResolverSimple(Interface):
 
     def getHostByName(name, timeout = (1, 3, 11, 45)):

twisted/internet/test/test_base.py

@@ -12 +12 @@
     from queue import Queue
 
 from zope.interface import implementer
+from zope.interface.verify import verifyClass
 
 from twisted.python.threadpool import ThreadPool
 from twisted.internet.interfaces import IReactorTime, IReactorThreads
+from twisted.internet.interfaces import INameResolver
 from twisted.internet.error import DNSLookupError
-from twisted.internet.base import ThreadedResolver, DelayedCall
+from twisted.internet.base import (
+    ThreadedNameResolver, ThreadedResolver, AddressInformation,
+    _ResolverComplexifier, DelayedCall)
 from twisted.internet.task import Clock
 from twisted.trial.unittest import TestCase
 
+from twisted.internet.test.test_tcp import FakeResolver
+
 
 @implementer(IReactorTime, IReactorThreads)
 class FakeReactor(object):
@@ -53 +59 @@
 
 
 
+class NameResolverAdapterTests(TestCase):
+    """
+    L{_ResolverComplexifier} adapters an L{IResolverSimple} provider
+    to L{INameResolver}.
+    """
+    def test_interface(self):
+        """
+        L{_ResolverComplexifier} implements L{INameResolver}.
+        """
+        self.assertTrue(verifyClass(INameResolver, _ResolverComplexifier))
+
+
+    def _successTest(self, address, family):
+        simple = FakeResolver({'example.com': address})
+        resolver = _ResolverComplexifier(simple)
+        d = resolver.getAddressInformation('example.com', 1234)
+        d.addCallback(
+            self.assertEquals, [
+                AddressInformation(
+                    family,
+                    socket.SOCK_STREAM,
+                    socket.IPPROTO_TCP,
+                    "",
+                    (address, 1234))])
+        return d
+
+
+    def test_ipv4Success(self):
+        """
+        L{_ResolverComplexifier} calls the wrapped object's
+        C{getHostByName} method and returns a L{Deferred} which fires
+        with a list of one element containing an AF_INET element with
+        the IPv4 address which C{getHostByName}'s L{Deferred} fired
+        with.
+        """
+        return self._successTest('192.168.1.12', socket.AF_INET)
+
+
+    def test_ipv6Success(self):
+        """
+        L{_ResolverComplexifier} calls the wrapped object's
+        C{getHostByName} method and returns a L{Deferred} which fires
+        with a list of one element containing an AF_INET6 element with
+        the IPv6 address which C{getHostByName}'s L{Deferred} fired
+        with.
+        """
+        return self._successTest('::1', socket.AF_INET6)
+
+
+    def test_failure(self):
+        """
+        The L{Deferred} L{_ResolverComplexifier.getAddressInformation}
+        returns fails if the wrapped resolver's C{getHostByName}
+        L{Deferred} fails.
+        """
+        error = DNSLookupError("Problems abound")
+        simple = FakeResolver({'example.com': error})
+        resolver = _ResolverComplexifier(simple)
+        d = resolver.getAddressInformation('example.com', 1234)
+        return self.assertFailure(d, DNSLookupError)
+
+
+
+class ThreadedNameResolverTests(TestCase):
+    """
+    Tests for L{ThreadedNameResolver}.
+    """
+    def test_interface(self):
+        """
+        L{ThreadedNameResolver} implements L{INameResolver}.
+        """
+        self.assertTrue(verifyClass(INameResolver, ThreadedNameResolver))
+
+
+    def test_success(self):
+        """
+        If the underlying C{getaddrinfo} library call completes
+        successfully and returns results, the L{Deferred} returned by
+        L{ThreadedNameResolver.getAddressInformation} fires with a
+        list of L{AddressInformation} instances representing those
+        results.
+        """
+
+
 class ThreadedResolverTests(TestCase):
     """
     Tests for L{ThreadedResolver}.

twisted/internet/test/test_core.py

@@ -12 +12 @@
 import signal
 import time
 import inspect
-
+import socket
+
+from zope.interface import implementer
+
+from twisted.internet.interfaces import INameResolver
 from twisted.internet.abstract import FileDescriptor
 from twisted.internet.error import ReactorAlreadyRunning, ReactorNotRestartable
-from twisted.internet.defer import Deferred
+from twisted.internet.defer import Deferred, succeed
+from twisted.internet.base import AddressInformation
 from twisted.internet.test.reactormixins import ReactorBuilder
 
 
+
 class ObjectModelIntegrationMixin(object):
     """
     Helpers for tests about the object model of reactor-related objects.
@@ -41 +47 @@
 
 
 
+@implementer(INameResolver)
+class MemoryNameResolver(object):
+    def __init__(self, names):
+        self._names = names
+
+    def getAddressInformation(self, name, service, family=None, type=None,
+                              protocol=None, flags=None):
+        return succeed([
+                address
+                for address
+                in self._names[name, service]
+                if family is None or family == address.family
+                and type is None or type == address.type
+                and protocol is None or protocol == address.protocol])
+
+
+
 class ObjectModelIntegrationTest(ReactorBuilder, ObjectModelIntegrationMixin):
     """
     Test details of object model integration against all reactors.
@@ -328 +351 @@
         self.assertEqual(events, ['tested'])
 
 
+    def test_resolve(self):
+        """
+        C{reactor.resolve(name)} calls the C{getAddressInformation}
+        method of the installed resolver and returns a L{Deferred}
+        which fires with the first C{AF_INET} family element from the
+        result of C{getAddressInformation}.
+        """
+        resolver = MemoryNameResolver({
+                ('example.com', 0): [
+                    AddressInformation(
+                        socket.AF_INET6,
+                        socket.SOCK_STREAM,
+                        socket.IPPROTO_TCP,
+                        "",
+                        ("::1", 0)),
+                    AddressInformation(
+                        socket.AF_INET,
+                        socket.SOCK_STREAM,
+                        socket.IPPROTO_TCP,
+                        "",
+                        ("127.0.0.1", 22))]})
+
+        reactor = self.buildReactor()
+        reactor.installResolver(resolver)
+        d = reactor.resolve("example.com")
+        d.addCallback(self.assertEquals, "127.0.0.1")
+        return d
+
 
 globals().update(SystemEventTestsBuilder.makeTestCaseClasses())
 globals().update(ObjectModelIntegrationTest.makeTestCaseClasses())

twisted/internet/test/test_tcp.py

@@ -25 +25 @@
     ConnectionLost, UserError, ConnectionRefusedError, ConnectionDone,
     ConnectionAborted)
 from twisted.internet.interfaces import (
-    ILoggingContext, IConnector, IReactorFDSet, IReactorSocket, IReactorTCP)
+    ILoggingContext, IConnector, IReactorFDSet, IReactorSocket, IReactorTCP, IResolverSimple)
 from twisted.internet.address import IPv4Address, IPv6Address
 from twisted.internet.defer import (
-    Deferred, DeferredList, maybeDeferred, gatherResults)
+    Deferred, DeferredList, maybeDeferred, gatherResults, succeed, fail)
 from twisted.internet.endpoints import TCP4ServerEndpoint, TCP4ClientEndpoint
+from twisted.internet.error import DNSLookupError
 from twisted.internet.protocol import ServerFactory, ClientFactory, Protocol
 from twisted.internet.interfaces import (
     IPushProducer, IPullProducer, IHalfCloseableProtocol)
@@ -108 +109 @@
     client.connect(address)
 
 
+class Stop(ClientFactory):
+    """
+    A client factory which stops a reactor when a connection attempt fails.
+    """
+    def __init__(self, reactor):
+        self.reactor = reactor
+
+
+    def clientConnectionFailed(self, connector, reason):
+        self.reactor.stop()
+
+
+@implementer(IResolverSimple)
+class FakeResolver:
+    """
+    A resolver implementation based on a C{dict} mapping names to addresses.
+    """
+
+    def __init__(self, names):
+        self.names = names
+
+
+    def getHostByName(self, name, timeout=None):
+        try:
+            return succeed(self.names[name])
+        except KeyError:
+            return fail(DNSLookupError("FakeResolver couldn't find " + name))
+
+
+
+class TCPClientTestsBuilder(ReactorBuilder):
+    """
+    Builder defining tests relating to L{IReactorTCP.connectTCP}.
+    """
+    def _freePort(self, interface='127.0.0.1'):
+        probe = socket.socket()
+        try:
+            probe.bind((interface, 0))
+            return probe.getsockname()
+        finally:
+            probe.close()
+
+    def test_clientConnectionFailedStopsReactor(self):
+        """
+        The reactor can be stopped by a client factory's
+        C{clientConnectionFailed} method.
+        """
+        host, port = self._freePort()
+        reactor = self.buildReactor()
+        reactor.connectTCP(host, port, Stop(reactor))
+
 
 class FakeSocket(object):
     """