FM / internet

/usr/lib/python3/dist-packages/twisted/internet/

/usr/lib/python3/dist-packages/twisted/internet

Name	Size	Mode	Actions
iocpreactor/	-	0755	rm
test/	-	0755	rm
__pycache__/	-	0755	rm
abstract.py	19274	0644	edit dl rm
address.py	5246	0644	edit dl rm
asyncioreactor.py	10553	0644	edit dl rm
base.py	44260	0644	edit dl rm
cfreactor.py	17501	0644	edit dl rm
default.py	1942	0644	edit dl rm
defer.py	71193	0644	edit dl rm
endpoints.py	77207	0644	edit dl rm
epollreactor.py	8493	0644	edit dl rm
error.py	12645	0644	edit dl rm
fdesc.py	3223	0644	edit dl rm
gireactor.py	6123	0644	edit dl rm
glib2reactor.py	1115	0644	edit dl rm
gtk2reactor.py	3614	0644	edit dl rm
gtk3reactor.py	2252	0644	edit dl rm
inotify.py	14691	0644	edit dl rm
interfaces.py	96515	0644	edit dl rm
kqreactor.py	10292	0644	edit dl rm
main.py	1054	0644	edit dl rm
pollreactor.py	6026	0644	edit dl rm
posixbase.py	26357	0644	edit dl rm
process.py	38896	0644	edit dl rm
protocol.py	27134	0644	edit dl rm
pyuisupport.py	817	0644	edit dl rm
reactor.py	1863	0644	edit dl rm
selectreactor.py	6215	0644	edit dl rm
serialport.py	2317	0644	edit dl rm
ssl.py	8444	0644	edit dl rm
stdio.py	1045	0644	edit dl rm
task.py	31119	0644	edit dl rm
tcp.py	54908	0644	edit dl rm
threads.py	3953	0644	edit dl rm
tksupport.py	2045	0644	edit dl rm
udp.py	18569	0644	edit dl rm
unix.py	21965	0644	edit dl rm
utils.py	7876	0644	edit dl rm
win32eventreactor.py	15193	0644	edit dl rm
wxreactor.py	5263	0644	edit dl rm
wxsupport.py	1363	0644	edit dl rm
_baseprocess.py	1913	0644	edit dl rm
_dumbwin32proc.py	13107	0644	edit dl rm
_glibbase.py	12813	0644	edit dl rm
_idna.py	1397	0644	edit dl rm
_newtls.py	9332	0644	edit dl rm
_pollingfile.py	8982	0644	edit dl rm
_posixserialport.py	1995	0644	edit dl rm
_posixstdio.py	4687	0644	edit dl rm
_producer_helpers.py	3788	0644	edit dl rm
_resolver.py	8530	0644	edit dl rm
_signals.py	2718	0644	edit dl rm
_sslverify.py	71770	0644	edit dl rm
_threadedselect.py	11764	0644	edit dl rm
_win32serialport.py	4744	0644	edit dl rm
_win32stdio.py	3204	0644	edit dl rm
__init__.py	521	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/twisted/internet/_resolver.py (8530B)

# -*- test-case-name: twisted.internet.test.test_resolver -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
IPv6-aware hostname resolution.

@see: L{IHostnameResolver}
"""

from __future__ import division, absolute_import

__metaclass__ = type

from socket import (getaddrinfo, AF_INET, AF_INET6, AF_UNSPEC, SOCK_STREAM,
                    SOCK_DGRAM, gaierror)

from zope.interface import implementer

from twisted.internet.interfaces import (IHostnameResolver, IHostResolution,
                                         IResolverSimple, IResolutionReceiver)
from twisted.internet.error import DNSLookupError
from twisted.internet.defer import Deferred
from twisted.internet.threads import deferToThreadPool
from twisted.internet.address import IPv4Address, IPv6Address
from twisted.python.compat import nativeString
from twisted.internet._idna import _idnaBytes
from twisted.logger import Logger

@implementer(IHostResolution)
class HostResolution(object):
    """
    The in-progress resolution of a given hostname.
    """

def __init__(self, name):
        """
        Create a L{HostResolution} with the given name.
        """
        self.name = name

_any = frozenset([IPv4Address, IPv6Address])

_typesToAF = {
    frozenset([IPv4Address]): AF_INET,
    frozenset([IPv6Address]): AF_INET6,
    _any: AF_UNSPEC,
}

_afToType = {
    AF_INET: IPv4Address,
    AF_INET6: IPv6Address,
}

_transportToSocket = {
    'TCP': SOCK_STREAM,
    'UDP': SOCK_DGRAM,
}

_socktypeToType = {
    SOCK_STREAM: 'TCP',
    SOCK_DGRAM: 'UDP',
}

@implementer(IHostnameResolver)
class GAIResolver(object):
    """
    L{IHostnameResolver} implementation that resolves hostnames by calling
    L{getaddrinfo} in a thread.
    """

def __init__(self, reactor, getThreadPool=None, getaddrinfo=getaddrinfo):
        """
        Create a L{GAIResolver}.

@param reactor: the reactor to schedule result-delivery on
        @type reactor: L{IReactorThreads}

@param getThreadPool: a function to retrieve the thread pool to use for
            scheduling name resolutions.  If not supplied, the use the given
            C{reactor}'s thread pool.
        @type getThreadPool: 0-argument callable returning a
            L{twisted.python.threadpool.ThreadPool}

@param getaddrinfo: a reference to the L{getaddrinfo} to use - mainly
            parameterized for testing.
        @type getaddrinfo: callable with the same signature as L{getaddrinfo}
        """
        self._reactor = reactor
        self._getThreadPool = (reactor.getThreadPool if getThreadPool is None
                               else getThreadPool)
        self._getaddrinfo = getaddrinfo

def resolveHostName(self, resolutionReceiver, hostName, portNumber=0,
                        addressTypes=None, transportSemantics='TCP'):
        """
        See L{IHostnameResolver.resolveHostName}

@param resolutionReceiver: see interface

@param hostName: see interface

@param portNumber: see interface

@param addressTypes: see interface

@param transportSemantics: see interface

@return: see interface
        """
        pool = self._getThreadPool()
        addressFamily = _typesToAF[_any if addressTypes is None
                                   else frozenset(addressTypes)]
        socketType = _transportToSocket[transportSemantics]
        def get():
            try:
                return self._getaddrinfo(hostName, portNumber, addressFamily,
                                         socketType)
            except gaierror:
                return []
        d = deferToThreadPool(self._reactor, pool, get)
        resolution = HostResolution(hostName)
        resolutionReceiver.resolutionBegan(resolution)
        @d.addCallback
        def deliverResults(result):
            for family, socktype, proto, cannoname, sockaddr in result:
                addrType = _afToType[family]
                resolutionReceiver.addressResolved(
                    addrType(_socktypeToType.get(socktype, 'TCP'), *sockaddr)
                )
            resolutionReceiver.resolutionComplete()
        return resolution

@implementer(IHostnameResolver)
class SimpleResolverComplexifier(object):
    """
    A converter from L{IResolverSimple} to L{IHostnameResolver}.
    """

_log = Logger()

def __init__(self, simpleResolver):
        """
        Construct a L{SimpleResolverComplexifier} with an L{IResolverSimple}.
        """
        self._simpleResolver = simpleResolver

@param resolutionReceiver: see interface

@param hostName: see interface

@param portNumber: see interface

@param addressTypes: see interface

@param transportSemantics: see interface

@return: see interface
        """
        # If it's str, we need to make sure that it's just ASCII.
        try:
            hostName = hostName.encode('ascii')
        except UnicodeEncodeError:
            # If it's not just ASCII, IDNA it. We don't want to give a Unicode
            # string with non-ASCII in it to Python 3, as if anyone passes that
            # to a Python 3 stdlib function, it will probably use the wrong
            # IDNA version and break absolutely everything
            hostName = _idnaBytes(hostName)

# Make sure it's passed down as a native str, to maintain the interface
        hostName = nativeString(hostName)

resolution = HostResolution(hostName)
        resolutionReceiver.resolutionBegan(resolution)
        onAddress = self._simpleResolver.getHostByName(hostName)
        def addressReceived(address):
            resolutionReceiver.addressResolved(IPv4Address('TCP', address,
                                                           portNumber))
        def errorReceived(error):
            if not error.check(DNSLookupError):
                self._log.failure("while looking up {name} with {resolver}",
                                  error, name=hostName,
                                  resolver=self._simpleResolver)
        onAddress.addCallbacks(addressReceived, errorReceived)
        def finish(result):
            resolutionReceiver.resolutionComplete()
        onAddress.addCallback(finish)
        return resolution

@implementer(IResolutionReceiver)
class FirstOneWins(object):
    """
    An L{IResolutionReceiver} which fires a L{Deferred} with its first result.
    """

def __init__(self, deferred):
        """
        @param deferred: The L{Deferred} to fire when the first resolution
            result arrives.
        """
        self._deferred = deferred
        self._resolved = False

def resolutionBegan(self, resolution):
        """
        See L{IResolutionReceiver.resolutionBegan}

@param resolution: See L{IResolutionReceiver.resolutionBegan}
        """
        self._resolution = resolution

def addressResolved(self, address):
        """
        See L{IResolutionReceiver.addressResolved}

@param address: See L{IResolutionReceiver.addressResolved}
        """
        if self._resolved:
            return
        self._resolved = True
        self._deferred.callback(address.host)

def resolutionComplete(self):
        """
        See L{IResolutionReceiver.resolutionComplete}
        """
        if self._resolved:
            return
        self._deferred.errback(DNSLookupError(self._resolution.name))

@implementer(IResolverSimple)
class ComplexResolverSimplifier(object):
    """
    A converter from L{IHostnameResolver} to L{IResolverSimple}
    """
    def __init__(self, nameResolver):
        """
        Create a L{ComplexResolverSimplifier} with an L{IHostnameResolver}.

@param nameResolver: The L{IHostnameResolver} to use.
        """
        self._nameResolver = nameResolver

def getHostByName(self, name, timeouts=()):
        """
        See L{IResolverSimple.getHostByName}

@param name: see L{IResolverSimple.getHostByName}

@param timeouts: see L{IResolverSimple.getHostByName}

@return: see L{IResolverSimple.getHostByName}
        """
        result = Deferred()
        self._nameResolver.resolveHostName(FirstOneWins(result), name, 0,
                                           [IPv4Address])
        return result

cmd: