HEX

File: //lib/python3/dist-packages/twisted/internet/__pycache__/_resolver.cpython-38.pyc
U

�b!�@s`dZddlmZmZmZmZmZmZmZddl	m
Z
ddlmZddl
mZmZddlmZddlmZddlmZmZmZmZdd	lmZdd
lmZddlmZe
e�Gdd
�d
��Ze eeg�Z!e eg�ee eg�ee!eiZ"eeeeiZ#eed�Z$edediZ%e
e�Gdd�d��Z&e
e�Gdd�d��Z'e
e�Gdd�d��Z(e
e�Gdd�d��Z)dS)z=
IPv6-aware hostname resolution.

@see: L{IHostnameResolver}
�)�AF_INET�AF_INET6�	AF_UNSPEC�
SOCK_DGRAM�SOCK_STREAM�gaierror�getaddrinfo)�implementer)�
_idnaBytes)�IPv4Address�IPv6Address)�Deferred)�DNSLookupError)�IHostnameResolver�IHostResolution�IResolutionReceiver�IResolverSimple)�deferToThreadPool)�Logger)�nativeStringc@s eZdZdZdd�Zdd�ZdS)�HostResolutionz9
    The in-progress resolution of a given hostname.
    cCs
||_dS)zA
        Create a L{HostResolution} with the given name.
        N)�name)�selfr�r�</usr/lib/python3/dist-packages/twisted/internet/_resolver.py�__init__-szHostResolution.__init__cCs
t��dS�N)�NotImplementedError�rrrr�cancel3szHostResolution.cancelN)�__name__�
__module__�__qualname__�__doc__rrrrrrr'sr)�TCP�UDPr$r%c@s(eZdZdZdefdd�Zd	dd�ZdS)
�GAIResolverzp
    L{IHostnameResolver} implementation that resolves hostnames by calling
    L{getaddrinfo} in a thread.
    NcCs$||_|dkr|jn||_||_dS)a�
        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}
        N)�_reactor�
getThreadPool�_getThreadPool�_getaddrinfo)r�reactorr(rrrrrWs�zGAIResolver.__init__rr$csr���}t|dkrtnt|��t|������fdd�}t�j||�}t��}	��|	�|j	�fdd��}
|	S)�<
        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
        Ncs0z�������WStk
r*gYSXdSr)r*rr)�
addressFamily�hostName�
portNumberr�
socketTyperr�get�s�z(GAIResolver.resolveHostName.<locals>.getcsD|D]2\}}}}}t|}��|t�|d�f|���q���dS�Nr$)�	_afToType�addressResolved�_socktypeToTyper1�resolutionComplete)�result�family�socktype�protoZ	cannoname�sockaddrZaddrType��resolutionReceiverrr�deliverResults�s�z3GAIResolver.resolveHostName.<locals>.deliverResults)
r)�
_typesToAF�_any�	frozenset�_transportToSocketrr'r�resolutionBegan�addCallback)rr=r.r/�addressTypes�transportSemantics�poolr1�d�
resolutionr>r)r-r.r/r=rr0r�resolveHostNamens�
zGAIResolver.resolveHostName)rNr$)r r!r"r#rrrJrrrrr&Ps�r&c@s(eZdZdZe�Zdd�Zd	dd�ZdS)
�SimpleResolverComplexifierzF
    A converter from L{IResolverSimple} to L{IHostnameResolver}.
    cCs
||_dS)zW
        Construct a L{SimpleResolverComplexifier} with an L{IResolverSimple}.
        N)�_simpleResolver)rZsimpleResolverrrrr�sz#SimpleResolverComplexifier.__init__rNr$cs�z��d��Wntk
r*t���YnXt���t��}��|��j���}��fdd�}��fdd�}	|�||	��fdd�}
|�	|
�|S)r,�asciics��td|���dSr2)r4r)�address)r/r=rr�addressReceived�szCSimpleResolverComplexifier.resolveHostName.<locals>.addressReceivedcs$|�t�s �jjd|��jd�dS)Nz'while looking up {name} with {resolver})r�resolver)�checkr�_log�failurerL)�error)r.rrr�
errorReceived�s
�zASimpleResolverComplexifier.resolveHostName.<locals>.errorReceivedcs���dSr)r6)r7r<rr�finish�sz:SimpleResolverComplexifier.resolveHostName.<locals>.finish)
�encode�UnicodeEncodeErrorr
rrrCrL�
getHostByName�addCallbacksrD)rr=r.r/rErFrIZ	onAddressrOrUrVr)r.r/r=rrrJ�s
	
z*SimpleResolverComplexifier.resolveHostName)rNr$)r r!r"r#rrRrrJrrrrrK�s
�rKc@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�FirstOneWinszT
    An L{IResolutionReceiver} which fires a L{Deferred} with its first result.
    cCs||_d|_dS)zp
        @param deferred: The L{Deferred} to fire when the first resolution
            result arrives.
        FN)�	_deferred�	_resolved)r�deferredrrrr�szFirstOneWins.__init__cCs
||_dS)z�
        See L{IResolutionReceiver.resolutionBegan}

        @param resolution: See L{IResolutionReceiver.resolutionBegan}
        N)�_resolution)rrIrrrrC�szFirstOneWins.resolutionBegancCs"|jr
dSd|_|j�|j�dS)z�
        See L{IResolutionReceiver.addressResolved}

        @param address: See L{IResolutionReceiver.addressResolved}
        NT)r]r\�callback�host)rrNrrrr4szFirstOneWins.addressResolvedcCs"|jr
dS|j�t|jj��dS)z?
        See L{IResolutionReceiver.resolutionComplete}
        N)r]r\�errbackrr_rrrrrr6szFirstOneWins.resolutionCompleteN)r r!r"r#rrCr4r6rrrrr[�s
r[c@s"eZdZdZdd�Zddd�ZdS)	�ComplexResolverSimplifierzE
    A converter from L{IHostnameResolver} to L{IResolverSimple}
    cCs
||_dS)z�
        Create a L{ComplexResolverSimplifier} with an L{IHostnameResolver}.

        @param nameResolver: The L{IHostnameResolver} to use.
        N)�
_nameResolver)r�nameResolverrrrrsz"ComplexResolverSimplifier.__init__rcCs"t�}|j�t|�|dtg�|S)z�
        See L{IResolverSimple.getHostByName}

        @param name: see L{IResolverSimple.getHostByName}

        @param timeouts: see L{IResolverSimple.getHostByName}

        @return: see L{IResolverSimple.getHostByName}
        r)r
rdrJr[r)rrZtimeoutsr7rrrrY&s
z'ComplexResolverSimplifier.getHostByNameN)r)r r!r"r#rrYrrrrrcsrcN)*r#�socketrrrrrrr�zope.interfacer	Ztwisted.internet._idnar
Ztwisted.internet.addressrr�twisted.internet.deferr
�twisted.internet.errorr�twisted.internet.interfacesrrrrZtwisted.internet.threadsr�twisted.loggerr�twisted.python.compatrrrAr@r?r3rBr5r&rKr[rcrrrr�<module>sR$
����RJ)